DEV: Remove unused code

Author: czgdp1807

src/libasr/pass/subroutine_from_function.cpp

@@ -125,99 +125,6 @@ class ReplaceFunctionCallWithSubroutineCall:
         apply_again(apply_again_)
         {}
 
-        template <typename LOOP_BODY>
-        void create_do_loop(const Location& loc, int result_rank,
-            Vec<ASR::expr_t*>& idx_vars, Vec<ASR::expr_t*>& idx_vars_value,
-            Vec<ASR::expr_t*>& loop_vars, Vec<ASR::stmt_t*>& doloop_body,
-            ASR::expr_t* op_expr, ASR::expr_t* result_var_, LOOP_BODY loop_body) {
-            PassUtils::create_idx_vars(idx_vars_value, result_rank, loc, al, current_scope, "_v");
-            PassUtils::create_idx_vars(idx_vars, result_rank, loc, al, current_scope, "_t");
-            loop_vars.from_pointer_n_copy(al, idx_vars.p, idx_vars.size());
-
-            ASR::stmt_t* doloop = nullptr;
-            ASR::ttype_t* int32_type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4));
-            ASR::expr_t* const_1 = ASRUtils::EXPR(ASR::make_IntegerConstant_t(al, loc, 1, int32_type));
-            for( int i = (int) loop_vars.size() - 1; i >= 0; i-- ) {
-                // TODO: Add an If debug node to check if the lower and upper bounds of both the arrays are same.
-                ASR::do_loop_head_t head;
-                head.m_v = loop_vars[i];
-                head.m_start = PassUtils::get_bound(result_var_, i + 1, "lbound", al);
-                head.m_end = PassUtils::get_bound(result_var_, i + 1, "ubound", al);
-                head.m_increment = nullptr;
-                head.loc = head.m_v->base.loc;
-                doloop_body.reserve(al, 1);
-                if( doloop == nullptr ) {
-                    loop_body();
-                } else {
-                    if( ASRUtils::is_array(ASRUtils::expr_type(op_expr)) ) {
-                        ASR::expr_t* idx_lb = PassUtils::get_bound(op_expr, i + 1, "lbound", al);
-                        ASR::stmt_t* set_to_one = ASRUtils::STMT(ASR::make_Assignment_t(
-                            al, loc, idx_vars_value[i + 1], idx_lb, nullptr));
-                        doloop_body.push_back(al, set_to_one);
-                    }
-                    doloop_body.push_back(al, doloop);
-                }
-                if( ASRUtils::is_array(ASRUtils::expr_type(op_expr)) ) {
-                    ASR::expr_t* inc_expr = ASRUtils::EXPR(ASR::make_IntegerBinOp_t(
-                        al, loc, idx_vars_value[i], ASR::binopType::Add, const_1, int32_type, nullptr));
-                    ASR::stmt_t* assign_stmt = ASRUtils::STMT(ASR::make_Assignment_t(
-                        al, loc, idx_vars_value[i], inc_expr, nullptr));
-                    doloop_body.push_back(al, assign_stmt);
-                }
-                doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, nullptr, head, doloop_body.p, doloop_body.size()));
-            }
-            if( ASRUtils::is_array(ASRUtils::expr_type(op_expr)) ) {
-                ASR::expr_t* idx_lb = PassUtils::get_bound(op_expr, 1, "lbound", al);
-                ASR::stmt_t* set_to_one = ASRUtils::STMT(ASR::make_Assignment_t(al, loc, idx_vars_value[0], idx_lb, nullptr));
-                pass_result.push_back(al, set_to_one);
-            }
-            pass_result.push_back(al, doloop);
-        }
-
-        #define allocate_result_var(op_arg, op_dims_arg, op_n_dims_arg) if( ASR::is_a<ASR::Allocatable_t>(*ASRUtils::expr_type(result_var_)) || \
-            ASR::is_a<ASR::Pointer_t>(*ASRUtils::expr_type(result_var_)) ) { \
-            bool is_dimension_empty = false; \
-            for( int i = 0; i < op_n_dims_arg; i++ ) { \
-                if( op_dims_arg->m_length == nullptr ) { \
-                    is_dimension_empty = true; \
-                    break; \
-                } \
-            } \
-            Vec<ASR::alloc_arg_t> alloc_args; \
-            alloc_args.reserve(al, 1); \
-            if( !is_dimension_empty ) { \
-                ASR::alloc_arg_t alloc_arg; \
-                alloc_arg.loc = loc; \
-                alloc_arg.m_len_expr = nullptr; \
-                alloc_arg.m_type = nullptr; \
-                alloc_arg.m_a = result_var_; \
-                alloc_arg.m_dims = op_dims_arg; \
-                alloc_arg.n_dims = op_n_dims_arg; \
-                alloc_args.push_back(al, alloc_arg); \
-            } else { \
-                Vec<ASR::dimension_t> alloc_dims; \
-                alloc_dims.reserve(al, op_n_dims_arg); \
-                for( int i = 0; i < op_n_dims_arg; i++ ) { \
-                    ASR::dimension_t alloc_dim; \
-                    alloc_dim.loc = loc; \
-                    alloc_dim.m_start = PassUtils::get_bound(op_arg, i + 1, "lbound", al); \
-                    alloc_dim.m_length = ASRUtils::compute_length_from_start_end(al, alloc_dim.m_start, \
-                        PassUtils::get_bound(op_arg, i + 1, "ubound", al)); \
-                    alloc_dims.push_back(al, alloc_dim); \
-                } \
-                ASR::alloc_arg_t alloc_arg; \
-                alloc_arg.loc = loc; \
-                alloc_arg.m_len_expr = nullptr; \
-                alloc_arg.m_type = nullptr; \
-                alloc_arg.m_a = result_var_; \
-                alloc_arg.m_dims = alloc_dims.p; \
-                alloc_arg.n_dims = alloc_dims.size(); \
-                alloc_args.push_back(al, alloc_arg); \
-            } \
-            pass_result.push_back(al, ASRUtils::STMT(ASR::make_Allocate_t(al, \
-                loc, alloc_args.p, alloc_args.size(), nullptr, nullptr, nullptr))); \
-        }
-
         void replace_FunctionCall(ASR::FunctionCall_t* x) {
             // The following checks if the name of a function actually
             // points to a subroutine. If true this would mean that the