lcompilers · certik · Oct 24, 2023 · Jul 16, 2023 · Jul 16, 2023 · Jul 17, 2023
diff --git a/src/libasr/asr_utils.cpp b/src/libasr/asr_utils.cpp
@@ -616,7 +616,9 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right,
                                     }
                                 }
                             }
-                            current_function_dependencies.push_back(al, s2c(al, matched_func_name));
+                            if (ASRUtils::symbol_parent_symtab(a_name)->get_counter() != curr_scope->get_counter()) {
+                                ADD_ASR_DEPENDENCIES_WITH_NAME(curr_scope, a_name, current_function_dependencies, s2c(al, matched_func_name));
+                            }  
                             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
                             ASRUtils::set_absent_optional_arguments_to_null(a_args, func, al);
                             asr = ASRUtils::make_FunctionCall_t_util(al, loc, a_name, sym,
@@ -699,7 +701,9 @@ void process_overloaded_unary_minus_function(ASR::symbol_t* proc, ASR::expr_t* o
                     }
                 }
             }
-            current_function_dependencies.push_back(al, s2c(al, matched_func_name));
+            if (ASRUtils::symbol_parent_symtab(a_name)->get_counter() != curr_scope->get_counter()) {
+                ADD_ASR_DEPENDENCIES_WITH_NAME(curr_scope, a_name, current_function_dependencies, s2c(al, matched_func_name));
+            }  
             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
             ASRUtils::set_absent_optional_arguments_to_null(a_args, func, al);
             asr = ASRUtils::make_FunctionCall_t_util(al, loc, a_name, proc,
@@ -870,7 +874,9 @@ void process_overloaded_assignment_function(ASR::symbol_t* proc, ASR::expr_t* ta
             if( a_name == nullptr ) {
                 err("Unable to resolve matched subroutine for assignment overloading, " + matched_subrout_name, loc);
             }
-            current_function_dependencies.push_back(al, s2c(al, matched_subrout_name));
+            if (ASRUtils::symbol_parent_symtab(a_name)->get_counter() != curr_scope->get_counter()) {
+                ADD_ASR_DEPENDENCIES_WITH_NAME(curr_scope, a_name, current_function_dependencies, s2c(al, matched_subrout_name));
+            }
             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
             ASRUtils::set_absent_optional_arguments_to_null(a_args, subrout, al);
             asr = ASRUtils::make_SubroutineCall_t_util(al, loc, a_name, sym,
@@ -1010,7 +1016,9 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right,
                             } else {
                                 return_type = ASRUtils::expr_type(func->m_return_var);
                             }
-                            current_function_dependencies.push_back(al, s2c(al, matched_func_name));
+                            if (ASRUtils::symbol_parent_symtab(a_name)->get_counter() != curr_scope->get_counter()) {
+                                ADD_ASR_DEPENDENCIES_WITH_NAME(curr_scope, a_name, current_function_dependencies, s2c(al, matched_func_name));
+                            }
                             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
                             ASRUtils::set_absent_optional_arguments_to_null(a_args, func, al);
                             asr = ASRUtils::make_FunctionCall_t_util(al, loc, a_name, sym,

diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h
@@ -14,6 +14,28 @@
 
 #include <complex>
 
+#define ADD_ASR_DEPENDENCIES(current_scope, final_sym, current_function_dependencies) ASR::symbol_t* asr_owner_sym = nullptr; \
+    if(current_scope->asr_owner && ASR::is_a<ASR::symbol_t>(*current_scope->asr_owner) ) { \
+        asr_owner_sym = ASR::down_cast<ASR::symbol_t>(current_scope->asr_owner); \
+    } \
+    SymbolTable* temp_scope = current_scope; \
+    if (asr_owner_sym && temp_scope->get_counter() != ASRUtils::symbol_parent_symtab(final_sym)->get_counter() && \
+            !ASR::is_a<ASR::AssociateBlock_t>(*asr_owner_sym) && !ASR::is_a<ASR::ExternalSymbol_t>(*final_sym) && \
+                !ASR::is_a<ASR::Variable_t>(*final_sym)) { \
+        current_function_dependencies.push_back(al, ASRUtils::symbol_name(final_sym)); \
+    } \
+
+#define ADD_ASR_DEPENDENCIES_WITH_NAME(current_scope, final_sym, current_function_dependencies, dep_name) ASR::symbol_t* asr_owner_sym = nullptr; \
+    if(current_scope->asr_owner && ASR::is_a<ASR::symbol_t>(*current_scope->asr_owner) ) { \
+        asr_owner_sym = ASR::down_cast<ASR::symbol_t>(current_scope->asr_owner); \
+    } \
+    SymbolTable* temp_scope = current_scope; \
+    if (asr_owner_sym && temp_scope->get_counter() != ASRUtils::symbol_parent_symtab(final_sym)->get_counter() && \
+            !ASR::is_a<ASR::AssociateBlock_t>(*asr_owner_sym) && !ASR::is_a<ASR::ExternalSymbol_t>(*final_sym) && \
+                !ASR::is_a<ASR::Variable_t>(*final_sym)) { \
+        current_function_dependencies.push_back(al, dep_name); \
+    } \
+
 namespace LCompilers  {
 
     namespace ASRUtils  {
@@ -554,6 +576,17 @@ static inline std::pair<char**, size_t> symbol_dependencies(const ASR::symbol_t
     }
 }
 
+static inline bool is_present_in_current_scope(ASR::ExternalSymbol_t* external_symbol, SymbolTable* current_scope) {
+        SymbolTable* scope = external_symbol->m_parent_symtab;
+        while (scope != nullptr) {
+            if (scope->get_counter() == current_scope->get_counter()) {
+                return true;
+            }
+            scope = scope->parent;
+        }
+        return false;
+    }
+
 static inline SymbolTable *symbol_parent_symtab(const ASR::symbol_t *f)
 {
     switch (f->type) {
@@ -3189,7 +3222,9 @@ class ReplaceArgVisitor: public ASR::BaseExprReplacer<ReplaceArgVisitor> {
             default:
                 break;
         }
-        current_function_dependencies.push_back(al, ASRUtils::symbol_name(new_es));
+        if (ASRUtils::symbol_parent_symtab(new_es)->get_counter() != current_scope->get_counter()) {
+            ADD_ASR_DEPENDENCIES(current_scope, new_es, current_function_dependencies);
+        }
         ASRUtils::insert_module_dependency(new_es, al, current_module_dependencies);
         x->m_name = new_es;
     }

diff --git a/src/libasr/asr_verify.cpp b/src/libasr/asr_verify.cpp
@@ -441,6 +441,20 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
         verify_unique_dependencies(x.m_dependencies, x.n_dependencies,
                                    x.m_name, x.base.base.loc);
 
+        // Get the x symtab.
+        SymbolTable *x_symtab = x.m_symtab;
+
+        // Dependencies of the function should be from function's parent symbol table.
+        for( size_t i = 0; i < x.n_dependencies; i++ ) {
+            std::string found_dep = x.m_dependencies[i];
+
+            // Get the symbol of the found_dep.
+            ASR::symbol_t* dep_sym = x_symtab->resolve_symbol(found_dep);
+
+            require(dep_sym != nullptr,
+                            "Dependency " + found_dep +  " is inside symbol table " + std::string(x.m_name));
+        }
+
         // Check if there are unnecessary dependencies
         // present in the dependency list of the function
         for( size_t i = 0; i < x.n_dependencies; i++ ) {
@@ -870,7 +884,19 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
             }
         }
 
-        function_dependencies.push_back(std::string(ASRUtils::symbol_name(x.m_name)));
+        ASR::symbol_t* asr_owner_sym = nullptr;
+        if(current_symtab->asr_owner &&  ASR::is_a<ASR::symbol_t>(*current_symtab->asr_owner) ) {
+            asr_owner_sym = ASR::down_cast<ASR::symbol_t>(current_symtab->asr_owner);
+        }
+
+        SymbolTable* temp_scope = current_symtab;
+
+        if (temp_scope->get_counter() != ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() &&
+            !ASR::is_a<ASR::AssociateBlock_t>(*asr_owner_sym) && !ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) &&
+                !ASR::is_a<ASR::Variable_t>(*x.m_name)) {
+            function_dependencies.push_back(std::string(ASRUtils::symbol_name(x.m_name)));
+        }
+
         if( ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) ) {
             ASR::ExternalSymbol_t* x_m_name = ASR::down_cast<ASR::ExternalSymbol_t>(x.m_name);
             if( x_m_name->m_external && ASR::is_a<ASR::Module_t>(*ASRUtils::get_asr_owner(x_m_name->m_external)) ) {
@@ -1003,7 +1029,19 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
     void visit_FunctionCall(const FunctionCall_t &x) {
         require(x.m_name,
             "FunctionCall::m_name must be present");
-        function_dependencies.push_back(std::string(ASRUtils::symbol_name(x.m_name)));
+        ASR::symbol_t* asr_owner_sym = nullptr;
+        if(current_symtab->asr_owner &&  ASR::is_a<ASR::symbol_t>(*current_symtab->asr_owner) ) {
+            asr_owner_sym = ASR::down_cast<ASR::symbol_t>(current_symtab->asr_owner);
+        }
+
+        SymbolTable* temp_scope = current_symtab;
+
+        if (asr_owner_sym && temp_scope->get_counter() != ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() &&
+            !ASR::is_a<ASR::AssociateBlock_t>(*asr_owner_sym) && !ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) &&
+                !ASR::is_a<ASR::Variable_t>(*x.m_name)) {
+            function_dependencies.push_back(std::string(ASRUtils::symbol_name(x.m_name)));
+        }
+
         if( ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) ) {
             ASR::ExternalSymbol_t* x_m_name = ASR::down_cast<ASR::ExternalSymbol_t>(x.m_name);
             if( x_m_name->m_external && ASR::is_a<ASR::Module_t>(*ASRUtils::get_asr_owner(x_m_name->m_external)) ) {

diff --git a/src/libasr/pass/instantiate_template.cpp b/src/libasr/pass/instantiate_template.cpp
@@ -305,8 +305,6 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator<SymbolInstantiator
         return new_x;
     }
 
-
-
     ASR::asr_t* duplicate_Var(ASR::Var_t *x) {
         std::string sym_name = ASRUtils::symbol_name(x->m_v);
         ASR::symbol_t* sym = duplicate_symbol(x->m_v);
@@ -430,9 +428,9 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator<SymbolInstantiator
                 throw LCompilersException("Cannot handle instantiation for the function call " + call_name);
             }
         }
-
-        dependencies.push_back(al, ASRUtils::symbol_name(name));
-
+        if (ASRUtils::symbol_parent_symtab(name)->get_counter() != current_scope->get_counter()) {
+            ADD_ASR_DEPENDENCIES(current_scope, name, dependencies);
+        }
         return ASRUtils::make_FunctionCall_t_util(al, x->base.base.loc, name, x->m_original_name,
             args.p, args.size(), type, value, dt);
     }
@@ -474,10 +472,10 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator<SymbolInstantiator
                 throw LCompilersException("Cannot handle instantiation for the function call " + call_name);
             }
         }
-
-        dependencies.push_back(al, ASRUtils::symbol_name(name));
-
-        return ASRUtils::make_SubroutineCall_t_util(al, x->base.base.loc, name,
+        if (ASRUtils::symbol_parent_symtab(name)->get_counter() != current_scope->get_counter()) {
+            ADD_ASR_DEPENDENCIES(current_scope, name, dependencies);
+        }
+        return ASRUtils::make_SubroutineCall_t_util(al, x->base.base.loc, name /* change this */,
             x->m_original_name, args.p, args.size(), dt, nullptr, false);
     }
 
@@ -651,6 +649,8 @@ void check_restriction(std::map<std::string, ASR::ttype_t*> type_subs,
                                 {f->m_args[i]->base.loc}),
                         diag::Label("Function's parameter " + avar + " of type " + atype,
                                 {arg->m_args[i]->base.loc})
+
+
                     }
                 ));
                 throw SemanticAbort();

diff --git a/src/libasr/pass/pass_utils.h b/src/libasr/pass/pass_utils.h
@@ -262,6 +262,7 @@ namespace LCompilers {
                 bool fill_function_dependencies;
                 bool fill_module_dependencies;
                 bool fill_variable_dependencies;
+                SymbolTable* current_scope;
 
             public:
 
@@ -273,10 +274,13 @@ namespace LCompilers {
                     function_dependencies.n = 0;
                     module_dependencies.n = 0;
                     variable_dependencies.n = 0;
+                    current_scope = nullptr;
                 }
 
                 void visit_Function(const ASR::Function_t& x) {
                     ASR::Function_t& xx = const_cast<ASR::Function_t&>(x);
+                    SymbolTable* current_scope_copy = current_scope;
+                    current_scope = xx.m_symtab;
                     SetChar function_dependencies_copy;
                     function_dependencies_copy.from_pointer_n_copy(al, function_dependencies.p, function_dependencies.size());
                     function_dependencies.n = 0;
@@ -291,6 +295,7 @@ namespace LCompilers {
                         function_dependencies_copy.p,
                         function_dependencies_copy.size()
                     );
+                    current_scope = current_scope_copy;
                 }
 
                 void visit_Module(const ASR::Module_t& x) {
@@ -327,9 +332,21 @@ namespace LCompilers {
                 }
 
                 void visit_FunctionCall(const ASR::FunctionCall_t& x) {
-                    if( fill_function_dependencies ) {
-                        function_dependencies.push_back(al, ASRUtils::symbol_name(x.m_name));
+                    if (fill_function_dependencies) { 
+                        ASR::symbol_t* asr_owner_sym = nullptr;
+                        if (current_scope->asr_owner && ASR::is_a<ASR::symbol_t>(*current_scope->asr_owner)) {
+                            asr_owner_sym = ASR::down_cast<ASR::symbol_t>(current_scope->asr_owner);
+                        }
+
+                        SymbolTable* temp_scope = current_scope;
+
+                        if (asr_owner_sym && temp_scope->get_counter() != ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() &&
+                            !ASR::is_a<ASR::AssociateBlock_t>(*asr_owner_sym) && !ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) &&
+                                !ASR::is_a<ASR::Variable_t>(*x.m_name)) {
+                            function_dependencies.push_back(al, ASRUtils::symbol_name(x.m_name));
+                        }
                     }
+
                     if( ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) &&
                         fill_module_dependencies ) {
                         ASR::ExternalSymbol_t* x_m_name = ASR::down_cast<ASR::ExternalSymbol_t>(x.m_name);
@@ -341,9 +358,21 @@ namespace LCompilers {
                 }
 
                 void visit_SubroutineCall(const ASR::SubroutineCall_t& x) {
-                    if( fill_function_dependencies ) {
-                        function_dependencies.push_back(al, ASRUtils::symbol_name(x.m_name));
+                    if (fill_function_dependencies) {
+                        ASR::symbol_t* asr_owner_sym = nullptr;
+                        if (current_scope->asr_owner && ASR::is_a<ASR::symbol_t>(*current_scope->asr_owner)) {
+                            asr_owner_sym = ASR::down_cast<ASR::symbol_t>(current_scope->asr_owner);
+                        }
+
+                        SymbolTable* temp_scope = current_scope;
+
+                        if (asr_owner_sym && temp_scope->get_counter() != ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() &&
+                            !ASR::is_a<ASR::AssociateBlock_t>(*asr_owner_sym) && !ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) &&
+                                !ASR::is_a<ASR::Variable_t>(*x.m_name)) {
+                            function_dependencies.push_back(al, ASRUtils::symbol_name(x.m_name));
+                        }
                     }
+
                     if( ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name) &&
                         fill_module_dependencies ) {
                         ASR::ExternalSymbol_t* x_m_name = ASR::down_cast<ASR::ExternalSymbol_t>(x.m_name);
@@ -360,6 +389,30 @@ namespace LCompilers {
                         visit_stmt(*(block->m_body[i]));
                     }
                 }
+
+                void visit_AssociateBlock(const ASR::AssociateBlock_t& x) {
+                    SymbolTable *parent_symtab = current_scope;
+                    current_scope = x.m_symtab;
+                    for (auto &a : x.m_symtab->get_scope()) {
+                        this->visit_symbol(*a.second);
+                    }
+                    for (size_t i=0; i<x.n_body; i++) {
+                        visit_stmt(*x.m_body[i]);
+                    }
+                    current_scope = parent_symtab;
+                }
+
+                void visit_Block(const ASR::Block_t& x) {
+                    SymbolTable *parent_symtab = current_scope;
+                    current_scope = x.m_symtab;
+                    for (auto &a : x.m_symtab->get_scope()) {
+                        this->visit_symbol(*a.second);
+                    }
+                    for (size_t i=0; i<x.n_body; i++) {
+                        visit_stmt(*x.m_body[i]);
+                    }
+                    current_scope = parent_symtab;
+                }                
         };
 
     namespace ReplacerUtils {

diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp
@@ -1187,15 +1187,23 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 args_new.reserve(al, func->n_args);
                 visit_expr_list_with_cast(func->m_args, func->n_args, args_new, args,
                     !ASRUtils::is_intrinsic_function2(func));
-                dependencies.push_back(al, ASRUtils::symbol_name(stemp));
+
+                if (ASRUtils::symbol_parent_symtab(stemp)->get_counter() != current_scope->get_counter()) {
+                    ADD_ASR_DEPENDENCIES(current_scope, stemp, dependencies);
+                }
+
                 return ASRUtils::make_FunctionCall_t_util(al, loc, stemp,
                                                 s_generic, args_new.p, args_new.size(),
                                                 a_type, value, nullptr);
             } else {
                 Vec<ASR::call_arg_t> args_new;
                 args_new.reserve(al, func->n_args);
                 visit_expr_list_with_cast(func->m_args, func->n_args, args_new, args);
-                dependencies.push_back(al, ASRUtils::symbol_name(stemp));
+
+                if (ASRUtils::symbol_parent_symtab(stemp)->get_counter() != current_scope->get_counter()) {
+                    ADD_ASR_DEPENDENCIES(current_scope, stemp, dependencies);
+                }
+
                 return ASRUtils::make_SubroutineCall_t_util(al, loc, stemp,
                     s_generic, args_new.p, args_new.size(), nullptr, nullptr, false);
             }
@@ -1457,7 +1465,10 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                 target_scope, target_scope, new_f, f);
         }
         dependencies.erase(s2c(al, func_name));
-        dependencies.push_back(al, s2c(al, new_func_name));
+
+        if (ASRUtils::symbol_parent_symtab(sym)->get_counter() != current_scope->get_counter()) {
+            ADD_ASR_DEPENDENCIES_WITH_NAME(current_scope, sym, dependencies, s2c(al, new_func_name));
+        }
         return t;
     }
 
@@ -5471,6 +5482,7 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
 
         SymbolTable *parent_scope = current_scope;
         current_scope = al.make_new<SymbolTable>(parent_scope);
+        current_scope->asr_owner = parent_scope->asr_owner;
         transform_stmts(body, x.n_body, x.m_body);
         int32_t total_syms = current_scope->get_scope().size();
         if( total_syms > 0 ) {

diff --git a/tests/reference/asr-array_01_decl-39cf894.stderr b/tests/reference/asr-array_01_decl-39cf894.stderr
@@ -0,0 +1,17 @@
+warning: The module 'numpy' located in $DIR/src/bin/../runtime/lpython_intrinsic_numpy.py cannot be loaded
+ --> tests/../integration_tests/array_01_decl.py:2:1
+  |
+2 | from numpy import empty, int16, int32, int64, float32, float64, complex64, complex128
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ imported here
+
+warning: The module 'lpython_builtin' located in $DIR/src/bin/../runtime/lpython_builtin.py cannot be loaded
+   --> $DIR/src/bin/../runtime/lpython_intrinsic_numpy.py:364:12
+    |
+364 |     return x1 % x2
+    |            ^^^^^^^ imported here
+
+semantic error: The symbol '_lpython_floordiv' not found in the module 'lpython_builtin'
+   --> $DIR/src/bin/../runtime/lpython_builtin.py:209:15
+    |
+209 |     if (n_ - (n_ // 2)*2) == 0:
+    |               ^^^^^^^