From 75f6432126336e5b44eddbe8a7c2d50894dc2e13 Mon Sep 17 00:00:00 2001
From: Thirumalai Shaktivel <thirumalaishaktivel@gmail.com>
Date: Sat, 25 Nov 2023 19:46:09 +0530
Subject: [PATCH 1/5] [ASR Pass] Symbolic: Simplify the Subroutine to use a
 common `create_bindc_function`

---
 src/libasr/pass/replace_symbolic.cpp | 354 ++++-----------------------
 1 file changed, 45 insertions(+), 309 deletions(-)

diff --git a/src/libasr/pass/replace_symbolic.cpp b/src/libasr/pass/replace_symbolic.cpp
index 4acbad65fa..75cdab5fb1 100644
--- a/src/libasr/pass/replace_symbolic.cpp
+++ b/src/libasr/pass/replace_symbolic.cpp
@@ -74,37 +74,38 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
                 intrinsic_func->m_args[0]);                                     \
             return iEq(function_call, i32(N)); }
 
-    ASR::stmt_t *basic_new_stack(const Location &loc, ASR::expr_t *x) {
-        std::string fn_name = "basic_new_stack";
+    ASR::symbol_t *create_bindc_function(const Location &loc,
+            const std::string &fn_name, std::vector<ASR::ttype_t *> args_type) {
+        ASRUtils::ASRBuilder b(al, loc);
         symbolic_dependencies.push_back(fn_name);
-        ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
-        ASR::symbol_t* basic_new_stack_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_new_stack_sym ) {
+        ASR::symbol_t* fn_sym = current_scope->resolve_symbol(fn_name);
+        if ( !fn_sym ) {
             std::string header = "symengine/cwrapper.h";
             SymbolTable *fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
 
-            Vec<ASR::expr_t*> args;
-            {
-                args.reserve(al, 1);
-                ASR::symbol_t *arg = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                    al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                    nullptr, nullptr, ASR::storage_typeType::Default, type, nullptr,
-                    ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-                fn_symtab->add_symbol(s2c(al, "x"), arg);
-                args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg)));
+            Vec<ASR::expr_t*> args; args.reserve(al, 1);
+            for (size_t i = 0; i < args_type.size(); i ++) {
+                std::string arg_name = "x_0" + std::to_string(i+1);
+                ASR::expr_t *arg = b.Variable(fn_symtab, arg_name, args_type[i],
+                    ASR::intentType::In, ASR::abiType::BindC, true);
+                args.push_back(al, arg);
             }
 
             Vec<ASR::stmt_t *> body; body.reserve(al, 1);
-            Vec<char *> dependencies; dependencies.reserve(al, 1);
-            basic_new_stack_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dependencies.p, dependencies.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false,
-                false, false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(fn_name, basic_new_stack_sym);
+            SetChar dep; dep.reserve(al, 1);
+            fn_sym = ASR::down_cast<ASR::symbol_t>( ASRUtils::make_Function_t_util(
+                al, loc, fn_symtab, s2c(al, fn_name), dep.p, dep.n, args.p, args.n,
+                body.p, body.n, nullptr, ASR::abiType::BindC, ASR::accessType::Public,
+                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
+                false, false, nullptr, 0, false, false, false, s2c(al, header)));
+            current_scope->parent->add_symbol(fn_name, fn_sym);
         }
+        return fn_sym;
+    }
 
+    ASR::stmt_t *basic_new_stack(const Location &loc, ASR::expr_t *x) {
+        ASR::symbol_t* basic_new_stack_sym = create_bindc_function(loc, "basic_new_stack",
+            {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))});
         Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
         call_arg.loc = loc;
@@ -115,36 +116,8 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::stmt_t *basic_free_stack(const Location &loc, ASR::expr_t *x) {
-        std::string fn_name = "basic_free_stack";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
-        ASR::symbol_t *basic_free_stack_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_free_stack_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable *fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args;
-            {
-                args.reserve(al, 1);
-                ASR::symbol_t *arg = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                    al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                    nullptr, nullptr, ASR::storage_typeType::Default, type, nullptr,
-                    ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-                fn_symtab->add_symbol(s2c(al, "x"), arg);
-                args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg)));
-            }
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char *> dependencies; dependencies.reserve(al, 1);
-            basic_free_stack_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dependencies.p, dependencies.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(fn_name, basic_free_stack_sym);
-        }
-
+        ASR::symbol_t* basic_free_stack_sym = create_bindc_function(loc, "basic_free_stack",
+            {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))});
         Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
         call_arg.loc = loc;
@@ -155,40 +128,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::stmt_t* basic_get_args(const Location& loc, ASR::expr_t *x, ASR::expr_t *y) {
-        std::string fn_name = "basic_get_args";
-        symbolic_dependencies.push_back(fn_name);
         ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
-        ASR::symbol_t *basic_get_args_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_get_args_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args;
-            args.reserve(al, 2);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, type,
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, type,
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dependencies; dependencies.reserve(al, 1);
-            basic_get_args_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dependencies.p, dependencies.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_get_args_sym);
-        }
-
+        ASR::symbol_t* basic_get_args_sym = create_bindc_function(loc,
+            "basic_get_args", {type, type});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 2);
         ASR::call_arg_t call_arg;
@@ -237,44 +179,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::stmt_t* vecbasic_get(const Location& loc, ASR::expr_t *x, ASR::expr_t *y, ASR::expr_t *z) {
-        std::string name = "vecbasic_get";
-        symbolic_dependencies.push_back(name);
         ASR::ttype_t *cptr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
-        ASR::symbol_t *vecbasic_get_sym = current_scope->resolve_symbol(name);
-        if ( !vecbasic_get_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 3);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, cptr_type,
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE((ASR::make_Integer_t(al, loc, 4))),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-            ASR::symbol_t* arg3 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "z"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, cptr_type,
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "z"), arg3);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg3)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            vecbasic_get_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n, nullptr,
-                ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, name), vecbasic_get_sym);
-        }
+        ASR::symbol_t* vecbasic_get_sym = create_bindc_function(loc, "vecbasic_get",
+            {cptr_type, ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)), cptr_type});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 3);
         ASR::call_arg_t call_arg;
@@ -335,38 +242,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
 
     ASR::stmt_t* basic_assign(const Location& loc,
             ASR::expr_t *target, ASR::expr_t *value) {
-        std::string fn_name = "basic_assign";
-        symbolic_dependencies.push_back(fn_name);
         ASR::ttype_t *cptr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
-        ASR::symbol_t *basic_assign_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_assign_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 2);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, cptr_type,
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, cptr_type,
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            basic_assign_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n, nullptr,
-                ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_assign_sym);
-        }
+        ASR::symbol_t* basic_assign_sym = create_bindc_function(loc, "basic_assign",
+            {cptr_type, cptr_type});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 2);
         ASR::call_arg_t call_arg;
@@ -520,38 +398,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
 
     ASR::stmt_t* integer_set_si(const Location& loc, ASR::expr_t *target,
             ASR::expr_t *value) {
-        std::string fn_name = "integer_set_si";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *integer_set_si_sym = current_scope->resolve_symbol(fn_name);
-        if ( !integer_set_si_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 2);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 8)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            integer_set_si_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), integer_set_si_sym);
-        }
-
+        ASR::symbol_t* integer_set_si_sym = create_bindc_function(loc,
+            "integer_set_si", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
+            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 8))});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 2);
         ASR::call_arg_t call_arg;
@@ -566,38 +415,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::stmt_t *symbol_set(const Location &loc, ASR::expr_t *target, ASR::expr_t *value) {
-        std::string fn_name = "symbol_set";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *symbol_set_sym = current_scope->resolve_symbol(fn_name);
-        if ( !symbol_set_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "s"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default,
-                ASRUtils::TYPE(ASR::make_Character_t(al, loc, 1, -2, nullptr)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "s"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            symbol_set_sym = ASR::down_cast<ASR::symbol_t>(ASRUtils::make_Function_t_util(al, loc,
-                fn_symtab, s2c(al, fn_name), dep.p, dep.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), symbol_set_sym);
-        }
-
+        ASR::symbol_t* symbol_set_sym = create_bindc_function(loc, "symbol_set",
+            {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(
+            ASR::make_Character_t(al, loc, 1, -2, nullptr))});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 2);
         ASR::call_arg_t call_arg;
@@ -613,80 +433,23 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
 
     ASR::stmt_t *basic_const(const Location &loc,
             const std::string &fn_name, ASR::expr_t* value) {
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_const_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_const_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            ASR::symbol_t* arg = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            basic_const_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_const_sym);
-        }
-
+        ASR::symbol_t* basic_const_sym = create_bindc_function(loc, fn_name,
+            {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
         call_arg.loc = loc;
         call_arg.m_value = value;
         call_args.push_back(al, call_arg);
-
         return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc,
             basic_const_sym, basic_const_sym, call_args.p, call_args.n, nullptr));
     }
 
     ASR::stmt_t *basic_binop(const Location &loc, const std::string &fn_name,
             ASR::expr_t* target, ASR::expr_t* op_01, ASR::expr_t* op_02) {
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_binop_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_binop_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 3);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-            ASR::symbol_t* arg3 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "z"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "z"), arg3);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg3)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            basic_binop_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_binop_sym);
-        }
+        ASR::ttype_t *cptr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
+        ASR::symbol_t* basic_binop_sym = create_bindc_function(loc, fn_name,
+            {cptr_type, cptr_type, cptr_type});
 
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 3);
@@ -705,36 +468,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
 
     ASR::stmt_t *basic_unaryop(const Location &loc, const std::string &fn_name,
             ASR::expr_t* target, ASR::expr_t* op_01) {
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_unaryop_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_unaryop_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 2);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg1);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1)));
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            basic_unaryop_sym = ASR::down_cast<ASR::symbol_t>(ASRUtils::make_Function_t_util(al, loc,
-                fn_symtab, s2c(al, fn_name), dep.p, dep.n, args.p, args.n, body.p, body.n,
-                nullptr, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_unaryop_sym);
-        }
-
+        ASR::symbol_t* basic_unaryop_sym = create_bindc_function(loc, fn_name,
+            {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(
+            ASR::make_CPtr_t(al, loc))});
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 2);
         ASR::call_arg_t call_arg;

From 544037793322bb30ed7979e05b56e028110d8737 Mon Sep 17 00:00:00 2001
From: Thirumalai Shaktivel <thirumalaishaktivel@gmail.com>
Date: Sat, 25 Nov 2023 19:46:19 +0530
Subject: [PATCH 2/5] [ASR Pass] Symbolic: Simplify the Function to use a
 common `create_bindc_function`

---
 src/libasr/pass/replace_symbolic.cpp | 202 ++++-----------------------
 1 file changed, 26 insertions(+), 176 deletions(-)

diff --git a/src/libasr/pass/replace_symbolic.cpp b/src/libasr/pass/replace_symbolic.cpp
index 75cdab5fb1..0f1820073c 100644
--- a/src/libasr/pass/replace_symbolic.cpp
+++ b/src/libasr/pass/replace_symbolic.cpp
@@ -75,7 +75,8 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
             return iEq(function_call, i32(N)); }
 
     ASR::symbol_t *create_bindc_function(const Location &loc,
-            const std::string &fn_name, std::vector<ASR::ttype_t *> args_type) {
+            const std::string &fn_name, std::vector<ASR::ttype_t *> args_type,
+            ASR::ttype_t *return_type=nullptr) {
         ASRUtils::ASRBuilder b(al, loc);
         symbolic_dependencies.push_back(fn_name);
         ASR::symbol_t* fn_sym = current_scope->resolve_symbol(fn_name);
@@ -86,16 +87,21 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
             Vec<ASR::expr_t*> args; args.reserve(al, 1);
             for (size_t i = 0; i < args_type.size(); i ++) {
                 std::string arg_name = "x_0" + std::to_string(i+1);
-                ASR::expr_t *arg = b.Variable(fn_symtab, arg_name, args_type[i],
-                    ASR::intentType::In, ASR::abiType::BindC, true);
-                args.push_back(al, arg);
+                args.push_back(al, b.Variable(fn_symtab, arg_name, args_type[i],
+                    ASR::intentType::In, ASR::abiType::BindC, true));
+            }
+            ASR::expr_t *return_var = nullptr;
+            if ( return_type ) {
+                char *return_var_name = s2c(al, "_lpython_return_variable");
+                return_var = b.Variable(fn_symtab, return_var_name, return_type,
+                    ASR::intentType::ReturnVar, ASR::abiType::BindC, false);
             }
 
             Vec<ASR::stmt_t *> body; body.reserve(al, 1);
             SetChar dep; dep.reserve(al, 1);
             fn_sym = ASR::down_cast<ASR::symbol_t>( ASRUtils::make_Function_t_util(
                 al, loc, fn_symtab, s2c(al, fn_name), dep.p, dep.n, args.p, args.n,
-                body.p, body.n, nullptr, ASR::abiType::BindC, ASR::accessType::Public,
+                body.p, body.n, return_var, ASR::abiType::BindC, ASR::accessType::Public,
                 ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
                 false, false, nullptr, 0, false, false, false, s2c(al, header)));
             current_scope->parent->add_symbol(fn_name, fn_sym);
@@ -197,38 +203,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::expr_t *vecbasic_size(const Location& loc, ASR::expr_t *x) {
-        std::string fn_name = "vecbasic_size";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *vecbasic_size_sym = current_scope->resolve_symbol(fn_name);
-        if ( !vecbasic_size_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            char *return_var_name = s2c(al, "_lpython_return_variable");
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, return_var_name, nullptr, 0, ASR::intentType::ReturnVar,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, false));
-            fn_symtab->add_symbol(return_var_name, arg1);
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            ASR::expr_t* return_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1));
-            vecbasic_size_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n,
-                return_var, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), vecbasic_size_sym);
-        }
+        ASR::symbol_t* vecbasic_size_sym = create_bindc_function(loc,
+            "vecbasic_size", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
+            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)));
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
@@ -258,40 +235,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::expr_t* basic_str(const Location& loc, ASR::expr_t *x) {
-        std::string fn_name = "basic_str";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_str_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_str_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            char *return_var_name = s2c(al, "_lpython_return_variable");
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, return_var_name, nullptr, 0, ASR::intentType::ReturnVar,
-                nullptr, nullptr, ASR::storage_typeType::Default,
-                ASRUtils::TYPE(ASR::make_Character_t(al, loc, 1, -2, nullptr)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, false));
-            fn_symtab->add_symbol(return_var_name, arg1);
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default,
-                ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), nullptr,
-                ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            ASR::expr_t* return_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1));
-            basic_str_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n, return_var,
-                ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_str_sym);
-        }
+        ASR::symbol_t* basic_str_sym = create_bindc_function(loc,
+            "basic_str", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
+            ASRUtils::TYPE(ASR::make_Character_t(al, loc, 1, -2, nullptr)));
         Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
         call_arg.loc = loc;
@@ -303,38 +249,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::expr_t* basic_get_type(const Location& loc, ASR::expr_t* value) {
-        std::string fn_name = "basic_get_type";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_get_type_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_get_type_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            char *return_var_name =s2c(al, "_lpython_return_variable");
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, return_var_name, nullptr, 0, ASR::intentType::ReturnVar,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, false));
-            fn_symtab->add_symbol(return_var_name, arg1);
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            ASR::expr_t* return_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1));
-            basic_get_type_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n, return_var,
-                ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_get_type_sym);
-        }
+        ASR::symbol_t* basic_get_type_sym = create_bindc_function(loc,
+            "basic_get_type", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
+            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)));
         Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
         call_arg.loc = loc;
@@ -347,42 +264,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
 
     ASR::expr_t* basic_compare(const Location& loc,
             std::string fn_name, ASR::expr_t *left, ASR::expr_t *right) {
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_compare_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_compare_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "_lpython_return_variable"), nullptr, 0, ASR::intentType::ReturnVar,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, false));
-            fn_symtab->add_symbol(s2c(al, "_lpython_return_variable"), arg1);
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-            ASR::symbol_t* arg3 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg3);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg3)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            ASR::expr_t* return_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1));
-            basic_compare_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n,
-                return_var, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_compare_sym);
-        }
+        ASR::symbol_t* basic_compare_sym = create_bindc_function(loc,
+            fn_name, {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
+            ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)));
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 1);
         ASR::call_arg_t call_arg;
@@ -485,43 +369,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::expr_t *basic_has_symbol(const Location &loc, ASR::expr_t *value_01, ASR::expr_t *value_02) {
-        std::string fn_name = "basic_has_symbol";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *basic_has_symbol_sym = current_scope->resolve_symbol(fn_name);
-        if ( !basic_has_symbol_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "_lpython_return_variable"), nullptr, 0, ASR::intentType::ReturnVar,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, false));
-            fn_symtab->add_symbol(s2c(al, "_lpython_return_variable"), arg1);
-            ASR::symbol_t* arg2 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "x"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "x"), arg2);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg2)));
-            ASR::symbol_t* arg3 = ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
-                al, loc, fn_symtab, s2c(al, "y"), nullptr, 0, ASR::intentType::In,
-                nullptr, nullptr, ASR::storage_typeType::Default, ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, true));
-            fn_symtab->add_symbol(s2c(al, "y"), arg3);
-            args.push_back(al, ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg3)));
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            ASR::expr_t* return_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1));
-            basic_has_symbol_sym = ASR::down_cast<ASR::symbol_t>(ASRUtils::make_Function_t_util(al, loc,
-                fn_symtab, s2c(al, fn_name), dep.p, dep.n, args.p, args.n, body.p, body.n,
-                return_var, ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), basic_has_symbol_sym);
-        }
-
+        ASR::symbol_t* basic_has_symbol_sym = create_bindc_function(loc,
+            "basic_has_symbol", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
+            ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)));
         Vec<ASR::call_arg_t> call_args;
         call_args.reserve(al, 1);
         ASR::call_arg_t call_arg1, call_arg2;

From a50e1ea71a9a7ec695cf127456a421d748d7134a Mon Sep 17 00:00:00 2001
From: Thirumalai Shaktivel <thirumalaishaktivel@gmail.com>
Date: Sat, 25 Nov 2023 20:00:03 +0530
Subject: [PATCH 3/5] [ASR Pass] Symbolic: Simplify the SubroutineCall

---
 src/libasr/pass/replace_symbolic.cpp | 126 ++++++---------------------
 1 file changed, 25 insertions(+), 101 deletions(-)

diff --git a/src/libasr/pass/replace_symbolic.cpp b/src/libasr/pass/replace_symbolic.cpp
index 0f1820073c..21f8b7d7b9 100644
--- a/src/libasr/pass/replace_symbolic.cpp
+++ b/src/libasr/pass/replace_symbolic.cpp
@@ -74,6 +74,19 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
                 intrinsic_func->m_args[0]);                                     \
             return iEq(function_call, i32(N)); }
 
+    ASR::stmt_t *SubroutineCall(const Location &loc, ASR::symbol_t *sym,
+            std::vector<ASR::expr_t *> args) {
+        Vec<ASR::call_arg_t> call_args; call_args.reserve(al, args.size());
+        for (auto &x: args) {
+            ASR::call_arg_t call_arg;
+            call_arg.loc = loc;
+            call_arg.m_value = x;
+            call_args.push_back(al, call_arg);
+        }
+        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, sym,
+            sym, call_args.p, call_args.n, nullptr));
+    }
+
     ASR::symbol_t *create_bindc_function(const Location &loc,
             const std::string &fn_name, std::vector<ASR::ttype_t *> args_type,
             ASR::ttype_t *return_type=nullptr) {
@@ -112,41 +125,20 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     ASR::stmt_t *basic_new_stack(const Location &loc, ASR::expr_t *x) {
         ASR::symbol_t* basic_new_stack_sym = create_bindc_function(loc, "basic_new_stack",
             {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))});
-        Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = x;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, basic_new_stack_sym,
-                    basic_new_stack_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_new_stack_sym, {x});
     }
 
     ASR::stmt_t *basic_free_stack(const Location &loc, ASR::expr_t *x) {
         ASR::symbol_t* basic_free_stack_sym = create_bindc_function(loc, "basic_free_stack",
             {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))});
-        Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = x;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, basic_free_stack_sym,
-            basic_free_stack_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_free_stack_sym, {x});
     }
 
     ASR::stmt_t* basic_get_args(const Location& loc, ASR::expr_t *x, ASR::expr_t *y) {
         ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
         ASR::symbol_t* basic_get_args_sym = create_bindc_function(loc,
             "basic_get_args", {type, type});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 2);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = x;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = y;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, basic_get_args_sym,
-            basic_get_args_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_get_args_sym, {x, y});
     }
 
     ASR::expr_t *vecbasic_new(const Location& loc) {
@@ -188,18 +180,7 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::ttype_t *cptr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
         ASR::symbol_t* vecbasic_get_sym = create_bindc_function(loc, "vecbasic_get",
             {cptr_type, ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)), cptr_type});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 3);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = x;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = y;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = z;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, vecbasic_get_sym,
-            vecbasic_get_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, vecbasic_get_sym, {x, y, z});
     }
 
     ASR::expr_t *vecbasic_size(const Location& loc, ASR::expr_t *x) {
@@ -222,16 +203,7 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::ttype_t *cptr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
         ASR::symbol_t* basic_assign_sym = create_bindc_function(loc, "basic_assign",
             {cptr_type, cptr_type});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 2);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = target;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = value;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, basic_assign_sym,
-            basic_assign_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_assign_sym, {target, value});
     }
 
     ASR::expr_t* basic_str(const Location& loc, ASR::expr_t *x) {
@@ -285,48 +257,21 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::symbol_t* integer_set_si_sym = create_bindc_function(loc,
             "integer_set_si", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)),
             ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 8))});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 2);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = target;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = value;
-        call_args.push_back(al, call_arg);
-
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, integer_set_si_sym,
-            integer_set_si_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, integer_set_si_sym, {target, value});
     }
 
     ASR::stmt_t *symbol_set(const Location &loc, ASR::expr_t *target, ASR::expr_t *value) {
         ASR::symbol_t* symbol_set_sym = create_bindc_function(loc, "symbol_set",
             {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(
             ASR::make_Character_t(al, loc, 1, -2, nullptr))});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 2);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = target;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = value;
-        call_args.push_back(al, call_arg);
-
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, symbol_set_sym,
-            symbol_set_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, symbol_set_sym, {target, value});
     }
 
     ASR::stmt_t *basic_const(const Location &loc,
             const std::string &fn_name, ASR::expr_t* value) {
         ASR::symbol_t* basic_const_sym = create_bindc_function(loc, fn_name,
             {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = value;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc,
-            basic_const_sym, basic_const_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_const_sym, {value});
     }
 
     ASR::stmt_t *basic_binop(const Location &loc, const std::string &fn_name,
@@ -334,20 +279,8 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::ttype_t *cptr_type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));
         ASR::symbol_t* basic_binop_sym = create_bindc_function(loc, fn_name,
             {cptr_type, cptr_type, cptr_type});
-
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 3);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = target;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = handle_argument(al, loc, op_01);
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = handle_argument(al, loc, op_02);
-        call_args.push_back(al, call_arg);
-
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, basic_binop_sym,
-            basic_binop_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_binop_sym, {target,
+            handle_argument(al, loc, op_01), handle_argument(al, loc, op_02)});
     }
 
     ASR::stmt_t *basic_unaryop(const Location &loc, const std::string &fn_name,
@@ -355,17 +288,8 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::symbol_t* basic_unaryop_sym = create_bindc_function(loc, fn_name,
             {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(
             ASR::make_CPtr_t(al, loc))});
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 2);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = target;
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = handle_argument(al, loc, op_01);
-        call_args.push_back(al, call_arg);
-
-        return ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, basic_unaryop_sym,
-            basic_unaryop_sym, call_args.p, call_args.n, nullptr));
+        return SubroutineCall(loc, basic_unaryop_sym, {target,
+            handle_argument(al, loc, op_01)});
     }
 
     ASR::expr_t *basic_has_symbol(const Location &loc, ASR::expr_t *value_01, ASR::expr_t *value_02) {

From b37eb39c0c549027e00ee797063fa95636c9b45b Mon Sep 17 00:00:00 2001
From: Thirumalai Shaktivel <thirumalaishaktivel@gmail.com>
Date: Sat, 25 Nov 2023 20:04:47 +0530
Subject: [PATCH 4/5] [ASR Pass] Symbolic: Simplify the FunctionCall

---
 src/libasr/pass/replace_symbolic.cpp | 72 ++++++++++------------------
 1 file changed, 24 insertions(+), 48 deletions(-)

diff --git a/src/libasr/pass/replace_symbolic.cpp b/src/libasr/pass/replace_symbolic.cpp
index 21f8b7d7b9..6b0eb75d7b 100644
--- a/src/libasr/pass/replace_symbolic.cpp
+++ b/src/libasr/pass/replace_symbolic.cpp
@@ -87,6 +87,19 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
             sym, call_args.p, call_args.n, nullptr));
     }
 
+    ASR::expr_t *FunctionCall(const Location &loc, ASR::symbol_t *sym,
+            std::vector<ASR::expr_t *> args, ASR::ttype_t *return_type) {
+        Vec<ASR::call_arg_t> call_args; call_args.reserve(al, args.size());
+        for (auto &x: args) {
+            ASR::call_arg_t call_arg;
+            call_arg.loc = loc;
+            call_arg.m_value = x;
+            call_args.push_back(al, call_arg);
+        }
+        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
+            sym, sym, call_args.p, call_args.n, return_type, nullptr, nullptr));
+    }
+
     ASR::symbol_t *create_bindc_function(const Location &loc,
             const std::string &fn_name, std::vector<ASR::ttype_t *> args_type,
             ASR::ttype_t *return_type=nullptr) {
@@ -187,15 +200,8 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::symbol_t* vecbasic_size_sym = create_bindc_function(loc,
             "vecbasic_size", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
             ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)));
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = x;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
-            vecbasic_size_sym, vecbasic_size_sym, call_args.p, call_args.n,
-            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)), nullptr, nullptr));
+        return FunctionCall(loc, vecbasic_size_sym, {x},
+            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)));
     }
 
     ASR::stmt_t* basic_assign(const Location& loc,
@@ -210,28 +216,16 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::symbol_t* basic_str_sym = create_bindc_function(loc,
             "basic_str", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
             ASRUtils::TYPE(ASR::make_Character_t(al, loc, 1, -2, nullptr)));
-        Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = x;
-        call_args.push_back(al, call_arg);
-        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
-            basic_str_sym, basic_str_sym, call_args.p, call_args.n,
-            ASRUtils::TYPE(ASR::make_Character_t(al, loc, 1, -2, nullptr)), nullptr, nullptr));
+        return FunctionCall(loc, basic_str_sym, {x},
+            ASRUtils::TYPE(ASR::make_Character_t(al, loc, 1, -2, nullptr)));
     }
 
     ASR::expr_t* basic_get_type(const Location& loc, ASR::expr_t* value) {
         ASR::symbol_t* basic_get_type_sym = create_bindc_function(loc,
             "basic_get_type", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
             ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)));
-        Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = handle_argument(al, loc, value);
-        call_args.push_back(al, call_arg);
-        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
-            basic_get_type_sym, basic_get_type_sym, call_args.p, call_args.n,
-            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)), nullptr, nullptr));
+        return FunctionCall(loc, basic_get_type_sym, {handle_argument(al, loc, value)},
+            ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4)));
     }
 
     ASR::expr_t* basic_compare(const Location& loc,
@@ -239,17 +233,8 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::symbol_t* basic_compare_sym = create_bindc_function(loc,
             fn_name, {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
             ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)));
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg;
-        call_arg.loc = loc;
-        call_arg.m_value = handle_argument(al, loc, left);
-        call_args.push_back(al, call_arg);
-        call_arg.m_value = handle_argument(al, loc, right);
-        call_args.push_back(al, call_arg);
-        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
-            basic_compare_sym, basic_compare_sym, call_args.p, call_args.n,
-            ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)), nullptr, nullptr));
+        return FunctionCall(loc, basic_compare_sym, {handle_argument(al, loc, left),
+            handle_argument(al, loc, right)}, ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)));
     }
 
     ASR::stmt_t* integer_set_si(const Location& loc, ASR::expr_t *target,
@@ -296,18 +281,9 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
         ASR::symbol_t* basic_has_symbol_sym = create_bindc_function(loc,
             "basic_has_symbol", {ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), ASRUtils::TYPE(ASR::make_CPtr_t(al, loc))},
             ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)));
-        Vec<ASR::call_arg_t> call_args;
-        call_args.reserve(al, 1);
-        ASR::call_arg_t call_arg1, call_arg2;
-        call_arg1.loc = loc;
-        call_arg1.m_value = handle_argument(al, loc, value_01);
-        call_args.push_back(al, call_arg1);
-        call_arg2.loc = loc;
-        call_arg2.m_value = handle_argument(al, loc, value_02);
-        call_args.push_back(al, call_arg2);
-        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
-            basic_has_symbol_sym, basic_has_symbol_sym, call_args.p, call_args.n,
-            ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)), nullptr, nullptr));
+        return FunctionCall(loc, basic_has_symbol_sym,
+            {handle_argument(al, loc, value_01), handle_argument(al, loc, value_02)},
+            ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4)));
     }
     /********************************** Utils *********************************/
 

From f1b3fb0b38a1b931eb2acc9cf674cf7d16fe330b Mon Sep 17 00:00:00 2001
From: Thirumalai Shaktivel <thirumalaishaktivel@gmail.com>
Date: Sat, 25 Nov 2023 20:13:20 +0530
Subject: [PATCH 5/5] [ASR Pass] Symbolic: Handle function with no arguments

---
 src/libasr/pass/replace_symbolic.cpp | 43 ++++++----------------------
 1 file changed, 8 insertions(+), 35 deletions(-)

diff --git a/src/libasr/pass/replace_symbolic.cpp b/src/libasr/pass/replace_symbolic.cpp
index 6b0eb75d7b..4464a1a1f4 100644
--- a/src/libasr/pass/replace_symbolic.cpp
+++ b/src/libasr/pass/replace_symbolic.cpp
@@ -110,10 +110,10 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
             std::string header = "symengine/cwrapper.h";
             SymbolTable *fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
 
-            Vec<ASR::expr_t*> args; args.reserve(al, 1);
-            for (size_t i = 0; i < args_type.size(); i ++) {
-                std::string arg_name = "x_0" + std::to_string(i+1);
-                args.push_back(al, b.Variable(fn_symtab, arg_name, args_type[i],
+            Vec<ASR::expr_t*> args; args.reserve(al, 1); int i = 1;
+            for (auto &type: args_type) {
+                std::string arg_name = "x_0" + std::to_string(i); i++;
+                args.push_back(al, b.Variable(fn_symtab, arg_name, type,
                     ASR::intentType::In, ASR::abiType::BindC, true));
             }
             ASR::expr_t *return_var = nullptr;
@@ -155,38 +155,11 @@ class ReplaceSymbolicVisitor : public PassUtils::PassVisitor<ReplaceSymbolicVisi
     }
 
     ASR::expr_t *vecbasic_new(const Location& loc) {
-        std::string fn_name = "vecbasic_new";
-        symbolic_dependencies.push_back(fn_name);
-        ASR::symbol_t *vecbasic_new_sym = current_scope->resolve_symbol(fn_name);
-        if ( !vecbasic_new_sym ) {
-            std::string header = "symengine/cwrapper.h";
-            SymbolTable* fn_symtab = al.make_new<SymbolTable>(current_scope->parent);
-
-            Vec<ASR::expr_t*> args;
-            args.reserve(al, 1);
-            char *arg_name = s2c(al, "_lpython_return_variable");
-            ASR::symbol_t* arg1 = ASR::down_cast<ASR::symbol_t>(
-                ASR::make_Variable_t(al, loc, fn_symtab, arg_name, nullptr, 0,
-                ASR::intentType::ReturnVar, nullptr, nullptr,
-                ASR::storage_typeType::Default, ASRUtils::TYPE((ASR::make_CPtr_t(al, loc))),
-                nullptr, ASR::abiType::BindC, ASR::Public, ASR::presenceType::Required, false));
-            fn_symtab->add_symbol(arg_name, arg1);
-
-            Vec<ASR::stmt_t*> body; body.reserve(al, 1);
-            Vec<char*> dep; dep.reserve(al, 1);
-            ASR::expr_t* return_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, arg1));
-            vecbasic_new_sym = ASR::down_cast<ASR::symbol_t>(
-                ASRUtils::make_Function_t_util(al, loc, fn_symtab, s2c(al, fn_name),
-                dep.p, dep.n, args.p, args.n, body.p, body.n, return_var,
-                ASR::abiType::BindC, ASR::accessType::Public,
-                ASR::deftypeType::Interface, s2c(al, fn_name), false, false, false,
-                false, false, nullptr, 0, false, false, false, s2c(al, header)));
-            current_scope->parent->add_symbol(s2c(al, fn_name), vecbasic_new_sym);
-        }
+        ASR::symbol_t* vecbasic_new_sym = create_bindc_function(loc,
+            "vecbasic_new", {}, ASRUtils::TYPE((ASR::make_CPtr_t(al, loc))));
         Vec<ASR::call_arg_t> call_args; call_args.reserve(al, 1);
-        return ASRUtils::EXPR(ASRUtils::make_FunctionCall_t_util(al, loc,
-            vecbasic_new_sym, vecbasic_new_sym, call_args.p, call_args.n,
-            ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)), nullptr, nullptr));
+        return FunctionCall(loc, vecbasic_new_sym, {},
+            ASRUtils::TYPE(ASR::make_CPtr_t(al, loc)));
     }
 
     ASR::stmt_t* vecbasic_get(const Location& loc, ASR::expr_t *x, ASR::expr_t *y, ASR::expr_t *z) {