DEV: Remove unused code

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