Implemented ASR checks for function dependencies

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) == curr_scope->parent) {
+                                current_function_dependencies.push_back(al, 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) == curr_scope->parent) {
+                current_function_dependencies.push_back(al, 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) == curr_scope->parent) {
+                current_function_dependencies.push_back(al, 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) == curr_scope->parent) {
+                                current_function_dependencies.push_back(al, 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,

src/libasr/asr_utils.h

@@ -544,6 +544,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) {
@@ -3023,7 +3034,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) == current_scope->parent) {
+            current_function_dependencies.push_back(al, ASRUtils::symbol_name(new_es));
+        }
         ASRUtils::insert_module_dependency(new_es, al, current_module_dependencies);
         x->m_name = new_es;
     }

src/libasr/asr_verify.cpp

@@ -441,6 +441,32 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
         verify_unique_dependencies(x.m_dependencies, x.n_dependencies,
                                    x.m_name, x.base.base.loc);
 
+        // Get the x parent symtab.
+        SymbolTable *sym = x.m_symtab->parent;
+
+        // 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 = sym->get_symbol(found_dep);
+
+            if (dep_sym == nullptr) {
+                // The symbol `dep_sym` is not in the parent symbol table. For
+                // now we allow one exception: it can also be in the global scope.
+                ASR::symbol_t* dep_sym_global = sym->resolve_symbol(found_dep);
+
+                if (dep_sym_global != nullptr && ASRUtils::symbol_parent_symtab(dep_sym_global)->parent == nullptr) {
+                    // This is a global scope symbol, which we allow for now
+                } else {
+                    // This is not a global scope symbol and not in the parent symbol table,
+                    // Return an error:
+                    require(dep_sym != nullptr,
+                            "Dependency " + found_dep +  " was not found in the parent 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++ ) {
@@ -868,7 +894,12 @@ class VerifyVisitor : public BaseWalkVisitor<VerifyVisitor>
             }
         }
 
-        function_dependencies.push_back(std::string(ASRUtils::symbol_name(x.m_name)));
+        if ((current_symtab->get_counter() !=  ASRUtils::symbol_parent_symtab(x.m_name)->get_counter()) ||
+            (ASRUtils::symbol_parent_symtab(x.m_name)->parent == nullptr)) {
+            // add to dependencies
+            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)) ) {
@@ -1001,7 +1032,13 @@ 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)));
+        // Check x.m_name is from parent sym tab.
+        if ((ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() != current_symtab->get_counter()) ||
+            (ASRUtils::symbol_parent_symtab(x.m_name)->parent == nullptr)) {
+            // add to dependencies
+            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)) ) {

src/libasr/pass/instantiate_template.cpp

@@ -344,7 +344,9 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator<SymbolInstantiator
                                              ASR::down_cast<ASR::Function_t>(name2));
             context_map[ASRUtils::symbol_name(name2)] = ASRUtils::symbol_name(name);
         }
-        dependencies.push_back(al, ASRUtils::symbol_name(name));
+        if (ASRUtils::symbol_parent_symtab(name) == template_scope->parent) {
+            dependencies.push_back(al, ASRUtils::symbol_name(name));
+        }
         return ASRUtils::make_FunctionCall_t_util(al, x->base.base.loc, name, x->m_original_name,
             args.p, args.size(), type, value, dt);
     }
@@ -370,7 +372,9 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator<SymbolInstantiator
             name = nested_t.instantiate_symbol(name2);
             context_map[ASRUtils::symbol_name(name2)] = ASRUtils::symbol_name(name);
         }
-        dependencies.push_back(al, ASRUtils::symbol_name(name));
+        if (ASRUtils::symbol_parent_symtab(name) == template_scope->parent) {
+            dependencies.push_back(al, ASRUtils::symbol_name(name));
+        }
         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);
     }

src/libasr/pass/pass_utils.h

@@ -249,6 +249,7 @@ namespace LCompilers {
                 bool fill_function_dependencies;
                 bool fill_module_dependencies;
                 bool fill_variable_dependencies;
+                SymbolTable* current_scope;
 
             public:
 
@@ -260,10 +261,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;
@@ -278,6 +282,7 @@ namespace LCompilers {
                         function_dependencies_copy.p,
                         function_dependencies_copy.size()
                     );
+                    current_scope = current_scope_copy;
                 }
 
                 void visit_Module(const ASR::Module_t& x) {
@@ -314,9 +319,38 @@ 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 &&
+                        ASRUtils::symbol_symtab(x.m_name) != nullptr &&
+                        ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() !=
+                        current_scope->get_counter()) {
+                        if (ASR::is_a<ASR::Function_t>(*x.m_name)) {
+                            ASR::Function_t *f = ASR::down_cast2<ASR::Function_t>(current_scope->asr_owner);
+
+                            // Check is x.m_name is not an argument.
+                            bool is_arg = false;
+
+                            for (size_t i=0; i<f->n_args; i++) {
+                                ASR::Var_t *arg = ASR::down_cast<ASR::Var_t>(f->m_args[i]);
+
+                                if (arg->m_v == x.m_name) {
+                                    is_arg = true;
+                                    break;
+                                }
+                            }
+
+                            if (!is_arg) {
+                                function_dependencies.push_back(al, ASRUtils::symbol_name(x.m_name));
+                            }
+                        }
                     }
+
+                    if (fill_function_dependencies && ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name)) {
+                        ASR::ExternalSymbol_t* external_symbol = ASR::down_cast<ASR::ExternalSymbol_t>(x.m_name);
+                        if (!ASRUtils::is_present_in_current_scope(external_symbol, current_scope)) {
+                            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);
@@ -328,9 +362,42 @@ 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 &&
+                        ASRUtils::symbol_symtab(x.m_name) != nullptr &&
+                        ASRUtils::symbol_parent_symtab(x.m_name)->get_counter() !=
+                        current_scope->get_counter()) {
+                        if (ASR::is_a<ASR::Function_t>(*x.m_name)) {
+                            // Get the function type from x.
+                            ASR::Function_t *f = ASR::down_cast2<ASR::Function_t>(current_scope->asr_owner);
+
+                            // Check is x.m_name is not an argument.
+                            bool is_arg = false;
+
+                            for (size_t i=0; i<f->n_args; i++) {
+                                // Cast f->m_args[i] to Var.
+                                ASR::Var_t *arg = ASR::down_cast<ASR::Var_t>(f->m_args[i]);
+
+                                // Check if x.m_name is an argument.
+                                if (arg->m_v == x.m_name) {
+                                    is_arg = true;
+                                    break;
+                                }
+                            }
+
+                            if (!is_arg) {
+                                function_dependencies.push_back(al, ASRUtils::symbol_name(x.m_name));
+                            }
+                        }
+                    }
+
+                    if (fill_function_dependencies && ASR::is_a<ASR::ExternalSymbol_t>(*x.m_name)) {
+                        ASR::ExternalSymbol_t* external_symbol = ASR::down_cast<ASR::ExternalSymbol_t>(x.m_name);
+
+                        if (!ASRUtils::is_present_in_current_scope(external_symbol, current_scope)) {
+                            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);

src/lpython/semantics/python_ast_to_asr.cpp

@@ -1325,15 +1325,34 @@ 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));
+
+                // Check if it is inside the parent symbol scope.
+                if(ASRUtils::symbol_parent_symtab(stemp) == func->m_symtab->parent) {
+                    dependencies.push_back(al, ASRUtils::symbol_name(stemp));
+                } else {
+                    // Check if it is not an Intrinsic Function.
+                    if( !ASRUtils::is_intrinsic_function2(func) ) {
+                        // Check if it is an External Symbol.
+                        if( ASR::is_a<ASR::ExternalSymbol_t>(*stemp) ) {
+                            ASR::ExternalSymbol_t* es = ASR::down_cast<ASR::ExternalSymbol_t>(stemp);
+                            // Only add dependency if both belong to same parent symbol table.
+                            if(ASRUtils::symbol_parent_symtab(es->m_external) == func->m_symtab->parent) {
+                                dependencies.push_back(al, ASRUtils::symbol_name(stemp));
+                            }
+                        }
+                    }
+                }
                 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()) {
+                    dependencies.push_back(al, ASRUtils::symbol_name(stemp));
+                }
                 return ASRUtils::make_SubroutineCall_t_util(al, loc, stemp,
                     s_generic, args_new.p, args_new.size(), nullptr, nullptr, false);
             }
@@ -1595,7 +1614,9 @@ 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) == current_scope->parent) {
+            dependencies.push_back(al, s2c(al, new_func_name));
+        }
         return t;
     }
 

tests/reference/asr-callback_01-df40fd5.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-callback_01-df40fd5.stdout",
-    "stdout_hash": "5be73c5b09034604701853c55fffbdca38993aa3f92782e89a50c91e",
+    "stdout_hash": "d8283ff4af45372de119998a592b0995335f8d6ada869664e3306a22",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0

tests/reference/asr-callback_01-df40fd5.stdout

@@ -506,7 +506,7 @@
                                         []
                                         .false.
                                     )
-                                    [func]
+                                    []
                                     [(Var 6 func)
                                     (Var 6 arg)]
                                     [(=

tests/reference/asr-cast-435c233.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-cast-435c233.stdout",
-    "stdout_hash": "601d0fda929bc1ee47ec591680476f69f32af980624d2fd504094091",
+    "stdout_hash": "a93c5a7141a3d175723f95e3422250bc69fa23fb1da39a6a132668dc",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0

tests/reference/asr-cast-435c233.stdout

@@ -126,7 +126,7 @@
                                         []
                                         .false.
                                     )
-                                    [list]
+                                    []
                                     []
                                     [(=
                                         (Var 3 s)

tests/reference/asr-complex1-f26c460.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-complex1-f26c460.stdout",
-    "stdout_hash": "f9bf5d60924825871eda0b6077447ff9650625d0d1f15c94f16ec0e6",
+    "stdout_hash": "79c039ef8f2b16c8518e689aaaf252a4dd5048a6a08df68a4453e7a8",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0

tests/reference/asr-complex1-f26c460.stdout

@@ -368,12 +368,7 @@
                                         []
                                         .false.
                                     )
-                                    [complex@__lpython_overloaded_0__complex
-                                    complex@__lpython_overloaded_1__complex
-                                    complex@__lpython_overloaded_5__complex
-                                    complex@__lpython_overloaded_2__complex
-                                    complex@__lpython_overloaded_9__complex
-                                    complex@__lpython_overloaded_13__complex]
+                                    []
                                     []
                                     [(=
                                         (Var 3 c)