#include <fstream>

#include <iostream>

#include <map>

#include <memory>

#include <string>

#include <cmath>

#include <vector>

#include <bitset>

#include <complex>

#include <sstream>

#include <iterator>

#include <libasr/asr.h>

#include <libasr/asr_utils.h>

#include <libasr/asr_verify.h>

#include <libasr/config.h>

#include <libasr/string_utils.h>

#include <libasr/utils.h>

#include <libasr/pass/global_stmts_program.h>

#include <libasr/pass/instantiate_template.h>

#include <libasr/modfile.h>

#include <lpython/python_ast.h>

#include <lpython/semantics/python_ast_to_asr.h>

#include <lpython/utils.h>

#include <lpython/semantics/semantic_exception.h>

#include <lpython/python_serialization.h>

#include <lpython/semantics/python_comptime_eval.h>

#include <lpython/semantics/python_attribute_eval.h>

#include <lpython/semantics/python_intrinsic_eval.h>

#include <lpython/parser/parser.h>

#include <libasr/serialization.h>

namespace LFortran::LPython {

namespace CastingUtil {

// Data structure which contains priorities for

// intrinsic types defined in ASR

const std::map<ASR::ttypeType, int>& type2weight = {

{ASR::ttypeType::Complex, 4},

{ASR::ttypeType::Real, 3},

{ASR::ttypeType::Integer, 2},

{ASR::ttypeType::Logical, 1}

};

// Data structure which contains casting rules for non-equal

// intrinsic types defined in ASR

const std::map<std::pair<ASR::ttypeType, ASR::ttypeType>, ASR::cast_kindType>& type_rules = {

{std::make_pair(ASR::ttypeType::Complex, ASR::ttypeType::Real), ASR::cast_kindType::ComplexToReal},

{std::make_pair(ASR::ttypeType::Complex, ASR::ttypeType::Logical), ASR::cast_kindType::ComplexToLogical},

{std::make_pair(ASR::ttypeType::Real, ASR::ttypeType::Complex), ASR::cast_kindType::RealToComplex},

{std::make_pair(ASR::ttypeType::Real, ASR::ttypeType::Integer), ASR::cast_kindType::RealToInteger},

{std::make_pair(ASR::ttypeType::Real, ASR::ttypeType::Logical), ASR::cast_kindType::RealToLogical},

{std::make_pair(ASR::ttypeType::Integer, ASR::ttypeType::Complex), ASR::cast_kindType::IntegerToComplex},

{std::make_pair(ASR::ttypeType::Integer, ASR::ttypeType::Real), ASR::cast_kindType::IntegerToReal},

{std::make_pair(ASR::ttypeType::Integer, ASR::ttypeType::Logical), ASR::cast_kindType::IntegerToLogical},

{std::make_pair(ASR::ttypeType::Logical, ASR::ttypeType::Real), ASR::cast_kindType::LogicalToReal},

{std::make_pair(ASR::ttypeType::Logical, ASR::ttypeType::Integer), ASR::cast_kindType::LogicalToInteger},

};

// Data structure which contains casting rules for equal intrinsic

// types but with different kinds.

const std::map<ASR::ttypeType, ASR::cast_kindType>& kind_rules = {

{ASR::ttypeType::Complex, ASR::cast_kindType::ComplexToComplex},

{ASR::ttypeType::Real, ASR::cast_kindType::RealToReal},

{ASR::ttypeType::Integer, ASR::cast_kindType::IntegerToInteger}

};

int get_type_priority(ASR::ttypeType type) {

if( type2weight.find(type) == type2weight.end() ) {

return -1;

}

return type2weight.at(type);

}

int get_src_dest(ASR::expr_t* left_expr, ASR::expr_t* right_expr,

ASR::expr_t*& src_expr, ASR::expr_t*& dest_expr,

ASR::ttype_t*& src_type, ASR::ttype_t*& dest_type,

bool is_assign) {

ASR::ttype_t* left_type = ASRUtils::type_get_past_pointer(ASRUtils::expr_type(left_expr));

ASR::ttype_t* right_type = ASRUtils::type_get_past_pointer(ASRUtils::expr_type(right_expr));

if( ASRUtils::check_equal_type(left_type, right_type) ||

ASRUtils::is_character(*left_type) || ASRUtils::is_character(*right_type) ) {

return 2;

}

if( is_assign ) {

if( ASRUtils::is_real(*left_type) && ASRUtils::is_integer(*right_type)) {

throw SemanticError("Assigning integer to float is not supported",

right_expr->base.loc);

}

if ( ASRUtils::is_complex(*left_type) && !ASRUtils::is_complex(*right_type)) {

throw SemanticError("Assigning non-complex to complex is not supported",

right_expr->base.loc);

}

dest_expr = left_expr, dest_type = left_type;

src_expr = right_expr, src_type = right_type;

return 1;

}

int casted_expr_signal = 2;

ASR::ttypeType left_Type = left_type->type, right_Type = right_type->type;

int left_kind = ASRUtils::extract_kind_from_ttype_t(left_type);

int right_kind = ASRUtils::extract_kind_from_ttype_t(right_type);

int left_priority = get_type_priority(left_Type);

int right_priority = get_type_priority(right_Type);

if( left_priority > right_priority ) {

src_expr = right_expr, src_type = right_type;

dest_expr = left_expr, dest_type = left_type;

casted_expr_signal = 1;

} else if( left_priority < right_priority ) {

src_expr = left_expr, src_type = left_type;

dest_expr = right_expr, dest_type = right_type;

casted_expr_signal = 0;

} else {

if( left_kind > right_kind ) {

src_expr = right_expr, src_type = right_type;

dest_expr = left_expr, dest_type = left_type;

casted_expr_signal = 1;

} else if( left_kind < right_kind ) {

src_expr = left_expr, src_type = left_type;

dest_expr = right_expr, dest_type = right_type;

casted_expr_signal = 0;

} else {

return 2;

}

}

return casted_expr_signal;

}

ASR::expr_t* perform_casting(ASR::expr_t* expr, ASR::ttype_t* src,

ASR::ttype_t* dest, Allocator& al) {

ASR::ttypeType src_type = src->type;

ASR::ttypeType dest_type = dest->type;

ASR::cast_kindType cast_kind;

if( src_type == dest_type ) {

if( kind_rules.find(src_type) == kind_rules.end() ) {

return expr;

}

cast_kind = kind_rules.at(src_type);

} else {

std::pair<ASR::ttypeType, ASR::ttypeType> cast_key = std::make_pair(src_type, dest_type);

if( type_rules.find(cast_key) == type_rules.end() ) {

return expr;

}

cast_kind = type_rules.at(cast_key);

}

return ASRUtils::EXPR(ASRUtils::make_Cast_t_value(al, expr->base.loc, expr,

cast_kind, dest));

}

}

int save_pyc_files(const LFortran::ASR::TranslationUnit_t &u,

std::string infile) {

LFORTRAN_ASSERT(LFortran::asr_verify(u));

std::string modfile_binary = LFortran::save_pycfile(u);

while( infile.back() != '.' ) {

infile.pop_back();

}

std::string modfile = infile + "pyc";

{

std::ofstream out;

out.open(modfile, std::ofstream::out | std::ofstream::binary);

out << modfile_binary;

}

return 0;

}

// Does a CPython style lookup for a module:

// * First the current directory (this is incorrect, we need to do it relative to the current file)

// * Then the LPython runtime directory

LFortran::Result<std::string> get_full_path(const std::string &filename,

const std::string &runtime_library_dir, std::string& input,

bool &ltypes, bool& enum_py) {

ltypes = false;

enum_py = false;

bool status = read_file(filename, input);

if (status) {

return filename;

} else {

std::string filename_intrinsic = runtime_library_dir + "/" + filename;

status = read_file(filename_intrinsic, input);

if (status) {

return filename_intrinsic;

} else {

// If this is `ltypes`, do a special lookup

if (filename == "ltypes.py") {

filename_intrinsic = runtime_library_dir + "/ltypes/" + filename;

status = read_file(filename_intrinsic, input);

if (status) {

ltypes = true;

return filename_intrinsic;

} else {

return LFortran::Error();

}

} else if (startswith(filename, "numpy.py")) {

filename_intrinsic = runtime_library_dir + "/lpython_intrinsic_" + filename;

status = read_file(filename_intrinsic, input);

if (status) {

return filename_intrinsic;

} else {

return LFortran::Error();

}

} else if (startswith(filename, "enum.py")) {

enum_py = true;

return LFortran::Error();

} else {

return LFortran::Error();

}

}

}

}

bool set_module_path(std::string infile0, std::vector<std::string> &rl_path,

std::string& infile, std::string& path_used, std::string& input,

bool& ltypes, bool& enum_py) {

for (auto path: rl_path) {

Result<std::string> rinfile = get_full_path(infile0, path, input, ltypes, enum_py);

if (rinfile.ok) {

infile = rinfile.result;

path_used = path;

return true;

}

}

return false;

}

ASR::TranslationUnit_t* compile_module_till_asr(Allocator& al,

std::vector<std::string> &rl_path, std::string infile,

const Location &loc,

const std::function<void (const std::string &, const Location &)> err) {

// TODO: diagnostic should be an argument to this function

diag::Diagnostics diagnostics;

Result<AST::ast_t*> r = parse_python_file(al, rl_path[0], infile,

diagnostics, false);

if (!r.ok) {

err("The file '" + infile + "' failed to parse", loc);

}

LFortran::LPython::AST::ast_t* ast = r.result;

// Convert the module from AST to ASR

LFortran::LocationManager lm;

lm.in_filename = infile;

Result<ASR::TranslationUnit_t*> r2 = python_ast_to_asr(al, *ast,

diagnostics, false, true, false, infile);

// TODO: Uncomment once a check is added for ensuring

// that module.py file hasn't changed between

// builds.

// save_pyc_files(*r2.result, infile + "c");

std::string input;

read_file(infile, input);

CompilerOptions compiler_options;

std::cerr << diagnostics.render(input, lm, compiler_options);

if (!r2.ok) {

LFORTRAN_ASSERT(diagnostics.has_error())

return nullptr; // Error

}

return r2.result;

}

ASR::Module_t* load_module(Allocator &al, SymbolTable *symtab,

const std::string &module_name,

const Location &loc, bool intrinsic,

std::vector<std::string> &rl_path,

bool &ltypes, bool& enum_py,

const std::function<void (const std::string &, const Location &)> err) {

if( module_name == "copy" ) {

return nullptr;

}

ltypes = false;

enum_py = false;

LFORTRAN_ASSERT(symtab);

if (symtab->get_scope().find(module_name) != symtab->get_scope().end()) {

ASR::symbol_t *m = symtab->get_symbol(module_name);

if (ASR::is_a<ASR::Module_t>(*m)) {

return ASR::down_cast<ASR::Module_t>(m);

} else {

err("The symbol '" + module_name + "' is not a module", loc);

}

}

LFORTRAN_ASSERT(symtab->parent == nullptr);

// Parse the module `module_name`.py to AST

std::string infile0 = module_name + ".py";

std::string infile0c = infile0 + "c";

std::string path_used = "", infile;

bool compile_module = true;

ASR::TranslationUnit_t* mod1 = nullptr;

std::string input;

bool found = set_module_path(infile0c, rl_path, infile,

path_used, input, ltypes, enum_py);

if( !found ) {

input.clear();

found = set_module_path(infile0, rl_path, infile,

path_used, input, ltypes, enum_py);

} else {

mod1 = load_pycfile(al, input, false);

fix_external_symbols(*mod1, *ASRUtils::get_tu_symtab(symtab));

LFORTRAN_ASSERT(asr_verify(*mod1));

compile_module = false;

}

if( enum_py ) {

return nullptr;

}

if (!found) {

err("Could not find the module '" + infile0 + "'", loc);

}

if (ltypes) return nullptr;

if( compile_module ) {

mod1 = compile_module_till_asr(al, rl_path, infile, loc, err);

}

// insert into `symtab`

std::vector<std::pair<std::string, ASR::Module_t*>> children_modules;

ASRUtils::extract_module_python(*mod1, children_modules, module_name);

ASR::Module_t* mod2 = nullptr;

for( auto& a: children_modules ) {

std::string a_name = a.first;

ASR::Module_t* a_mod = a.second;

if( a_name == module_name ) {

a_mod->m_name = s2c(al, module_name);

a_mod->m_intrinsic = intrinsic;

mod2 = a_mod;

}

symtab->add_symbol(a_name, (ASR::symbol_t*)a_mod);

a_mod->m_symtab->parent = symtab;

}

if (intrinsic) {

// TODO: I think we should just store intrinsic once, in the module

// itself

// Mark each function as intrinsic also

for (auto &item : mod2->m_symtab->get_scope()) {

if (ASR::is_a<ASR::Function_t>(*item.second)) {

ASR::Function_t *s = ASR::down_cast<ASR::Function_t>(item.second);

if (s->m_abi == ASR::abiType::Source) {

s->m_abi = ASR::abiType::Intrinsic;

}

if (s->n_body == 0) {

std::string name = s->m_name;

if (name == "ubound" || name == "lbound") {

s->m_deftype = ASR::deftypeType::Interface;

}

}

}

}

}

// and return it

return mod2;

}

ASR::symbol_t* import_from_module(Allocator &al, ASR::Module_t *m, SymbolTable *current_scope,

std::string mname, std::string cur_sym_name, std::string new_sym_name,

const Location &loc) {

ASR::symbol_t *t = m->m_symtab->resolve_symbol(cur_sym_name);

if (!t) {

throw SemanticError("The symbol '" + cur_sym_name + "' not found in the module '" + mname + "'",

loc);

}

if (current_scope->get_scope().find(cur_sym_name) != current_scope->get_scope().end()) {

throw SemanticError(cur_sym_name + " already defined", loc);

}

if (ASR::is_a<ASR::Function_t>(*t)) {

ASR::Function_t *mfn = ASR::down_cast<ASR::Function_t>(t);

// `mfn` is the Function in a module. Now we construct

// an ExternalSymbol that points to it.

Str name;

name.from_str(al, new_sym_name);

char *cname = name.c_str(al);

ASR::asr_t *fn = ASR::make_ExternalSymbol_t(

al, mfn->base.base.loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)mfn,

m->m_name, nullptr, 0, mfn->m_name,

ASR::accessType::Public

);

return ASR::down_cast<ASR::symbol_t>(fn);

} else if (ASR::is_a<ASR::Variable_t>(*t)) {

ASR::Variable_t *mv = ASR::down_cast<ASR::Variable_t>(t);

// `mv` is the Variable in a module. Now we construct

// an ExternalSymbol that points to it.

Str name;

name.from_str(al, new_sym_name);

char *cname = name.c_str(al);

ASR::asr_t *v = ASR::make_ExternalSymbol_t(

al, mv->base.base.loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)mv,

m->m_name, nullptr, 0, mv->m_name,

ASR::accessType::Public

);

return ASR::down_cast<ASR::symbol_t>(v);

} else if (ASR::is_a<ASR::GenericProcedure_t>(*t)) {

ASR::GenericProcedure_t *gt = ASR::down_cast<ASR::GenericProcedure_t>(t);

Str name;

name.from_str(al, new_sym_name);

char *cname = name.c_str(al);

ASR::asr_t *v = ASR::make_ExternalSymbol_t(

al, gt->base.base.loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)gt,

m->m_name, nullptr, 0, gt->m_name,

ASR::accessType::Public

);

return ASR::down_cast<ASR::symbol_t>(v);

} else {

throw SemanticError("Only Subroutines, Functions and Variables are currently supported in 'import'",

loc);

}

LFORTRAN_ASSERT(false);

return nullptr;

}

template <class Derived>

class CommonVisitor : public AST::BaseVisitor<Derived> {

public:

diag::Diagnostics &diag;

ASR::asr_t *tmp;

/*

If `tmp` is not null, then `tmp_vec` is ignored and `tmp` is used as the only result (statement or

expression). If `tmp` is null, then `tmp_vec` is used to return any number of statements:

0 (no statement returned), 1 (redundant, one should use `tmp` for that), 2, 3, ... etc.

*/

std::vector<ASR::asr_t *> tmp_vec;

Allocator &al;

SymbolTable *current_scope;

// The current_module contains the current module that is being visited;

// this is used to append to the module dependencies if needed

ASR::Module_t *current_module = nullptr;

Vec<char *> current_module_dependencies;

// True for the main module, false for every other one

// The main module is stored directly in TranslationUnit, other modules are Modules

bool main_module;

PythonIntrinsicProcedures intrinsic_procedures;

ProceduresDatabase procedures_db;

AttributeHandler attr_handler;

IntrinsicNodeHandler intrinsic_node_handler;

std::map<int, ASR::symbol_t*> &ast_overload;

std::string parent_dir;

Vec<ASR::stmt_t*> *current_body;

ASR::ttype_t* ann_assign_target_type;

std::map<std::string, int> generic_func_nums;

std::map<std::string, std::map<std::string, ASR::ttype_t*>> generic_func_subs;

std::vector<ASR::symbol_t*> rt_vec;

CommonVisitor(Allocator &al, SymbolTable *symbol_table,

diag::Diagnostics &diagnostics, bool main_module,

std::map<int, ASR::symbol_t*> &ast_overload, std::string parent_dir)

: diag{diagnostics}, al{al}, current_scope{symbol_table}, main_module{main_module},

ast_overload{ast_overload}, parent_dir{parent_dir},

current_body{nullptr}, ann_assign_target_type{nullptr} {

current_module_dependencies.reserve(al, 4);

}

ASR::asr_t* resolve_variable(const Location &loc, const std::string &var_name) {

SymbolTable *scope = current_scope;

ASR::symbol_t *v = scope->resolve_symbol(var_name);

if (!v) {

diag.semantic_error_label("Variable '" + var_name

+ "' is not declared", {loc},

"'" + var_name + "' is undeclared");

throw SemanticAbort();

}

return ASR::make_Var_t(al, loc, v);

}

ASR::symbol_t* resolve_intrinsic_function(const Location &loc, const std::string &remote_sym) {

LFORTRAN_ASSERT(intrinsic_procedures.is_intrinsic(remote_sym))

std::string module_name = intrinsic_procedures.get_module(remote_sym, loc);

SymbolTable *tu_symtab = ASRUtils::get_tu_symtab(current_scope);

std::string rl_path = get_runtime_library_dir();

std::vector<std::string> paths = {rl_path, parent_dir};

bool ltypes, enum_py;

ASR::Module_t *m = load_module(al, tu_symtab, module_name,

loc, true, paths,

ltypes, enum_py,

[&](const std::string &msg, const Location &loc) { throw SemanticError(msg, loc); }

);

LFORTRAN_ASSERT(!ltypes && !enum_py)

ASR::symbol_t *t = m->m_symtab->resolve_symbol(remote_sym);

if (!t) {

throw SemanticError("The symbol '" + remote_sym

+ "' not found in the module '" + module_name + "'",

loc);

} else if (! (ASR::is_a<ASR::GenericProcedure_t>(*t)

|| ASR::is_a<ASR::Function_t>(*t)

)) {

throw SemanticError("The symbol '" + remote_sym

+ "' found in the module '" + module_name + "', "

+ "but it is not a function, subroutine or a generic procedure.",

loc);

}

char *fn_name = ASRUtils::symbol_name(t);

ASR::asr_t *fn = ASR::make_ExternalSymbol_t(

al, t->base.loc,

/* a_symtab */ current_scope,

/* a_name */ fn_name,

t,

m->m_name, nullptr, 0, fn_name,

ASR::accessType::Private

);

std::string sym = fn_name;

current_scope->add_symbol(sym, ASR::down_cast<ASR::symbol_t>(fn));

ASR::symbol_t *v = ASR::down_cast<ASR::symbol_t>(fn);

// Now we need to add the module `m` with the intrinsic function

// into the current module dependencies

if (current_module) {

// We are in body visitor, the module is already constructed

// and available as current_module.

// Add the module `m` to current module dependencies

Vec<char*> vec;

vec.from_pointer_n_copy(al, current_module->m_dependencies,

current_module->n_dependencies);

if (!present(vec, m->m_name)) {

vec.push_back(al, m->m_name);

current_module->m_dependencies = vec.p;

current_module->n_dependencies = vec.size();

}

} else {

// We are in the symtab visitor or body visitor and we are

// constructing a module, so current_module is not available yet

// (the current_module_dependencies is not used in body visitor)

if (!present(current_module_dependencies, m->m_name)) {

current_module_dependencies.push_back(al, m->m_name);

}

}

return v;

}

void handle_attribute(ASR::expr_t *s, std::string attr_name,

const Location &loc, Vec<ASR::expr_t*> &args) {

tmp = attr_handler.get_attribute(s, attr_name, al, loc, args, diag);

return;

}

void fill_expr_in_ttype_t(std::vector<ASR::expr_t*>& exprs, ASR::dimension_t* dims, size_t n_dims) {

for( size_t i = 0; i < n_dims; i++ ) {

exprs.push_back(dims[i].m_start);

exprs.push_back(dims[i].m_length);

}

}

void fix_exprs_ttype_t(std::vector<ASR::expr_t*>& exprs,

Vec<ASR::call_arg_t>& orig_args,

ASR::Function_t* orig_func=nullptr) {

ASRUtils::ExprStmtDuplicator expr_duplicator(al);

expr_duplicator.allow_procedure_calls = true;

ASRUtils::ReplaceArgVisitor arg_replacer(al, current_scope, orig_func,

orig_args);

for( size_t i = 0; i < exprs.size(); i++ ) {

ASR::expr_t* expri = exprs[i];

if (expri) {

expr_duplicator.success = true;

ASR::expr_t* expri_copy = expr_duplicator.duplicate_expr(expri);

LFORTRAN_ASSERT(expr_duplicator.success);

arg_replacer.current_expr = &expri_copy;

arg_replacer.replace_expr(expri_copy);

exprs[i] = expri_copy;

}

}

}

ASR::ttype_t* handle_return_type(ASR::ttype_t *return_type, const Location &loc,

Vec<ASR::call_arg_t>& args,

ASR::Function_t* f=nullptr) {

// Rebuild the return type if needed and make FunctionCalls use ExternalSymbol

std::vector<ASR::expr_t*> func_calls;

switch( return_type->type ) {

case ASR::ttypeType::Character: {

ASR::Character_t *t = ASR::down_cast<ASR::Character_t>(return_type);

func_calls.push_back(t->m_len_expr);

fill_expr_in_ttype_t(func_calls, t->m_dims, t->n_dims);

fix_exprs_ttype_t(func_calls, args, f);

Vec<ASR::dimension_t> new_dims;

new_dims.reserve(al, t->n_dims);

for( size_t i = 1; i < func_calls.size(); i += 2 ) {

ASR::dimension_t new_dim;

new_dim.loc = func_calls[i]->base.loc;

new_dim.m_start = func_calls[i];

new_dim.m_length = func_calls[i + 1];

new_dims.push_back(al, new_dim);

}

int64_t a_len = t->m_len;

if( func_calls[0] ) {

a_len = ASRUtils::extract_len<SemanticError>(func_calls[0], loc);

}

return ASRUtils::TYPE(ASR::make_Character_t(al, loc, t->m_kind, a_len, func_calls[0], new_dims.p, new_dims.size()));

}

case ASR::ttypeType::Integer: {

ASR::Integer_t *t = ASR::down_cast<ASR::Integer_t>(return_type);

fill_expr_in_ttype_t(func_calls, t->m_dims, t->n_dims);

fix_exprs_ttype_t(func_calls, args, f);

Vec<ASR::dimension_t> new_dims;

new_dims.reserve(al, t->n_dims);

for( size_t i = 0; i < func_calls.size(); i += 2 ) {

ASR::dimension_t new_dim;

new_dim.loc = func_calls[i]->base.loc;

new_dim.m_start = func_calls[i];

new_dim.m_length = func_calls[i + 1];

new_dims.push_back(al, new_dim);

}

return ASRUtils::TYPE(ASR::make_Integer_t(al, loc, t->m_kind, new_dims.p, new_dims.size()));

}

case ASR::ttypeType::Real: {

ASR::Real_t *t = ASR::down_cast<ASR::Real_t>(return_type);

fill_expr_in_ttype_t(func_calls, t->m_dims, t->n_dims);

fix_exprs_ttype_t(func_calls, args, f);

Vec<ASR::dimension_t> new_dims;

new_dims.reserve(al, t->n_dims);

for( size_t i = 0; i < func_calls.size(); i += 2 ) {

ASR::dimension_t new_dim;

new_dim.loc = func_calls[i]->base.loc;

new_dim.m_start = func_calls[i];

new_dim.m_length = func_calls[i + 1];

new_dims.push_back(al, new_dim);

}

return ASRUtils::TYPE(ASR::make_Real_t(al, loc, t->m_kind, new_dims.p, new_dims.size()));

break;

}

default: {

return return_type;

}

}

return nullptr;

}

void visit_expr_list(AST::expr_t** exprs, size_t n,

Vec<ASR::expr_t*> exprs_vec) {

LFORTRAN_ASSERT(exprs_vec.reserve_called);

for( size_t i = 0; i < n; i++ ) {

this->visit_expr(*exprs[i]);

exprs_vec.push_back(al, ASRUtils::EXPR(tmp));

}

}

void visit_expr_list(AST::expr_t** exprs, size_t n,

Vec<ASR::call_arg_t>& call_args_vec) {

LFORTRAN_ASSERT(call_args_vec.reserve_called);

for( size_t i = 0; i < n; i++ ) {

this->visit_expr(*exprs[i]);

ASR::expr_t* expr = nullptr;

ASR::call_arg_t arg;

if (tmp) {

expr = ASRUtils::EXPR(tmp);

arg.loc = expr->base.loc;

}

arg.m_value = expr;

call_args_vec.push_back(al, arg);

}

}

int64_t find_argument_position_from_name(ASR::Function_t* orig_func, std::string arg_name,

const Location& call_loc, bool raise_error) {

int64_t arg_position = -1;

for( size_t i = 0; i < orig_func->n_args; i++ ) {

ASR::Var_t* arg_Var = ASR::down_cast<ASR::Var_t>(orig_func->m_args[i]);

std::string original_arg_name = ASRUtils::symbol_name(arg_Var->m_v);

if( original_arg_name == arg_name ) {

return i;

}

}

for ( size_t i = 0; i < orig_func->n_restrictions; i++ ) {

ASR::symbol_t* rt = orig_func->m_restrictions[i];

std::string rt_name = ASRUtils::symbol_name(rt);

if ( rt_name == arg_name ) {

return -2;

}

}

if( raise_error && arg_position == -1 ) {

throw SemanticError("Function " + std::string(orig_func->m_name) +

" doesn't have an argument named '" + arg_name + "'",

call_loc);

}

return arg_position;

}

bool visit_expr_list(AST::expr_t** pos_args, size_t n_pos_args,

AST::keyword_t* kwargs, size_t n_kwargs,

Vec<ASR::call_arg_t>& call_args_vec,

std::map<std::string, ASR::symbol_t*>& rt_subs,

ASR::Function_t* orig_func, const Location& call_loc,

bool raise_error=true) {

LFORTRAN_ASSERT(call_args_vec.reserve_called);

// Fill the whole call_args_vec with nullptr

// This is for error handling later on.

for( size_t i = 0; i < n_pos_args + n_kwargs; i++ ) {

ASR::call_arg_t call_arg;

Location loc;

loc.first = loc.last = 1;

call_arg.m_value = nullptr;

call_arg.loc = loc;

call_args_vec.push_back(al, call_arg);

}

// Now handle positional arguments in the following loop

for( size_t i = 0; i < n_pos_args; i++ ) {

this->visit_expr(*pos_args[i]);

ASR::expr_t* expr = ASRUtils::EXPR(tmp);

call_args_vec.p[i].loc = expr->base.loc;

call_args_vec.p[i].m_value = expr;

}

// Now handle keyword arguments in the following loop

for( size_t i = 0; i < n_kwargs; i++ ) {

this->visit_expr(*kwargs[i].m_value);

ASR::expr_t* expr = ASRUtils::EXPR(tmp);

std::string arg_name = std::string(kwargs[i].m_arg);

int64_t arg_pos = find_argument_position_from_name(orig_func, arg_name, call_loc, raise_error);

if( arg_pos == -1 ) {

return false;

}

// Special treatment for argument to generic function's restriction

if (arg_pos == -2) {

if (ASR::is_a<ASR::Var_t>(*expr)) {

ASR::Var_t* var = ASR::down_cast<ASR::Var_t>(expr);

rt_subs[arg_name] = var->m_v;

}

continue;

}

if( call_args_vec[arg_pos].m_value != nullptr ) {

if( !raise_error ) {

return false;

}

throw SemanticError(std::string(orig_func->m_name) + "() got multiple values for argument '"

+ arg_name + "'",

call_loc);

}

call_args_vec.p[arg_pos].loc = expr->base.loc;

call_args_vec.p[arg_pos].m_value = expr;

}

return true;

}

void visit_expr_list(Vec<ASR::call_arg_t>& exprs, size_t n,

Vec<ASR::expr_t*>& exprs_vec) {

LFORTRAN_ASSERT(exprs_vec.reserve_called);

for( size_t i = 0; i < n; i++ ) {

exprs_vec.push_back(al, exprs[i].m_value);

}

}

void visit_expr_list_with_cast(ASR::expr_t** m_args, size_t n_args,

Vec<ASR::call_arg_t>& call_args_vec,

Vec<ASR::call_arg_t>& args) {

LFORTRAN_ASSERT(call_args_vec.reserve_called);

for (size_t i = 0; i < n_args; i++) {

ASR::call_arg_t c_arg;

c_arg.loc = args[i].loc;

c_arg.m_value = args[i].m_value;

cast_helper(m_args[i], c_arg.m_value, true);

call_args_vec.push_back(al, c_arg);

}

}

ASR::ttype_t* get_type_from_var_annotation(std::string var_annotation,

const Location& loc, Vec<ASR::dimension_t>& dims,

AST::expr_t** m_args=nullptr, size_t n_args=0) {

ASR::ttype_t* type = nullptr;

if (var_annotation == "i8") {

type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,

1, dims.p, dims.size()));

} else if (var_annotation == "i16") {

type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,

2, dims.p, dims.size()));

} else if (var_annotation == "i32") {

type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,

4, dims.p, dims.size()));

} else if (var_annotation == "i64") {

type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,

8, dims.p, dims.size()));

} else if (var_annotation == "f32") {

type = ASRUtils::TYPE(ASR::make_Real_t(al, loc,

4, dims.p, dims.size()));

} else if (var_annotation == "f64") {

type = ASRUtils::TYPE(ASR::make_Real_t(al, loc,

8, dims.p, dims.size()));

} else if (var_annotation == "c32") {

type = ASRUtils::TYPE(ASR::make_Complex_t(al, loc,

4, dims.p, dims.size()));

} else if (var_annotation == "c64") {

type = ASRUtils::TYPE(ASR::make_Complex_t(al, loc,

8, dims.p, dims.size()));

} else if (var_annotation == "str") {

type = ASRUtils::TYPE(ASR::make_Character_t(al, loc,

1, -2, nullptr, dims.p, dims.size()));

} else if (var_annotation == "bool") {

type = ASRUtils::TYPE(ASR::make_Logical_t(al, loc,

4, dims.p, dims.size()));

} else if (var_annotation == "CPtr") {

type = ASRUtils::TYPE(ASR::make_CPtr_t(al, loc));

} else if (var_annotation == "pointer") {

LFORTRAN_ASSERT(n_args == 1);

AST::expr_t* underlying_type = m_args[0];

type = ast_expr_to_asr_type(underlying_type->base.loc, *underlying_type);

type = ASRUtils::TYPE(ASR::make_Pointer_t(al, loc, type));

} else {

ASR::symbol_t *s = current_scope->resolve_symbol(var_annotation);

if (s) {

if (ASR::is_a<ASR::Variable_t>(*s)) {

ASR::Variable_t *var_sym = ASR::down_cast<ASR::Variable_t>(s);

if (var_sym->m_type->type == ASR::ttypeType::TypeParameter) {

ASR::TypeParameter_t *type_param = ASR::down_cast<ASR::TypeParameter_t>(var_sym->m_type);

return ASRUtils::TYPE(ASR::make_TypeParameter_t(al, loc,

type_param->m_param, dims.p, dims.size()));

}

} else {

ASR::symbol_t *der_sym = ASRUtils::symbol_get_past_external(s);

if( der_sym ) {

if ( ASR::is_a<ASR::DerivedType_t>(*der_sym) ) {

return ASRUtils::TYPE(ASR::make_Derived_t(al, loc, der_sym, dims.p, dims.size()));

} else if( ASR::is_a<ASR::EnumType_t>(*der_sym) ) {

return ASRUtils::TYPE(ASR::make_Enum_t(al, loc, der_sym, dims.p, dims.size()));

} else if( ASR::is_a<ASR::UnionType_t>(*der_sym) ) {

return ASRUtils::TYPE(ASR::make_Union_t(al, loc, der_sym, dims.p, dims.size()));

}

}

}

}

throw SemanticError("Unsupported type annotation: " + var_annotation, loc);

}

return type;

}

// Function to create appropriate call based on symbol type. If it is external

// generic symbol then it changes the name accordingly.

ASR::asr_t* make_call_helper(Allocator &al, ASR::symbol_t* s, SymbolTable *current_scope,

Vec<ASR::call_arg_t> args, std::string call_name, const Location &loc,

bool ignore_return_value=false, AST::expr_t** pos_args=nullptr, size_t n_pos_args=0,

AST::keyword_t* kwargs=nullptr, size_t n_kwargs=0) {

if (intrinsic_node_handler.is_present(call_name)) {

return intrinsic_node_handler.get_intrinsic_node(call_name, al, loc,

args);

}

if (call_name == "list" && (args.size() == 0 || args[0].m_value == nullptr)) {

if (ann_assign_target_type) {

ASR::ttype_t *type = ASRUtils::get_contained_type(ann_assign_target_type);

ASR::ttype_t* list_type = ASRUtils::TYPE(ASR::make_List_t(al, loc, type));

Vec<ASR::expr_t*> list;

list.reserve(al, 1);

return ASR::make_ListConstant_t(al, loc, list.p,

list.size(), list_type);

}

return nullptr;

}

ASR::symbol_t *s_generic = nullptr, *stemp = s;

// Type map for generic functions

std::map<std::string, ASR::ttype_t*> subs;

std::map<std::string, ASR::symbol_t*> rt_subs;

// handling ExternalSymbol

s = ASRUtils::symbol_get_past_external(s);

bool is_generic_procedure = ASR::is_a<ASR::GenericProcedure_t>(*s);

if (ASR::is_a<ASR::GenericProcedure_t>(*s)) {

s_generic = stemp;

ASR::GenericProcedure_t *p = ASR::down_cast<ASR::GenericProcedure_t>(s);

int idx = -1;

if( n_kwargs > 0 ) {

args.reserve(al, n_pos_args + n_kwargs);

for( size_t iproc = 0; iproc < p->n_procs; iproc++ ) {

args.n = 0;

ASR::Function_t* orig_func = ASR::down_cast<ASR::Function_t>(p->m_procs[iproc]);

if( !visit_expr_list(pos_args, n_pos_args, kwargs, n_kwargs,

args, rt_subs, orig_func, loc, false) ) {

continue;

}

idx = ASRUtils::select_generic_procedure(args, *p, loc,

[&](const std::string &msg, const Location &loc) { throw SemanticError(msg, loc); },

false);

if( idx == (int) iproc ) {

break;

}

}

if( idx == -1 ) {

throw SemanticError("Arguments do not match for any generic procedure, " + std::string(p->m_name), loc);

}

} else {

idx = ASRUtils::select_generic_procedure(args, *p, loc,

[&](const std::string &msg, const Location &loc) { throw SemanticError(msg, loc); });

}

s = p->m_procs[idx];

std::string remote_sym = ASRUtils::symbol_name(s);

std::string local_sym = ASRUtils::symbol_name(s);

if (ASR::is_a<ASR::ExternalSymbol_t>(*stemp)) {

local_sym = std::string(p->m_name) + "@" + local_sym;

}

SymbolTable *symtab = current_scope;

if (symtab->resolve_symbol(local_sym) == nullptr) {

LFORTRAN_ASSERT(ASR::is_a<ASR::ExternalSymbol_t>(*stemp));

std::string mod_name = ASR::down_cast<ASR::ExternalSymbol_t>(stemp)->m_module_name;

ASR::symbol_t *mt = symtab->resolve_symbol(mod_name);

ASR::Module_t *m = ASR::down_cast<ASR::Module_t>(mt);

stemp = import_from_module(al, m, symtab, mod_name,

remote_sym, local_sym, loc);

LFORTRAN_ASSERT(ASR::is_a<ASR::ExternalSymbol_t>(*stemp));

symtab->add_symbol(local_sym, stemp);

s = ASRUtils::symbol_get_past_external(stemp);

} else {

stemp = symtab->resolve_symbol(local_sym);

}

}

if (ASR::is_a<ASR::Function_t>(*s)) {

ASR::Function_t *func = ASR::down_cast<ASR::Function_t>(s);

if( n_kwargs > 0 && !is_generic_procedure ) {

args.reserve(al, n_pos_args + n_kwargs);

visit_expr_list(pos_args, n_pos_args, kwargs, n_kwargs,

args, rt_subs, func, loc);

}

if (func->m_is_restriction) {

rt_vec.push_back(s);

} else if (func->n_type_params > 0) {

if (n_pos_args != func->n_args) {

std::string fnd = std::to_string(n_pos_args);

std::string org = std::to_string(func->n_args);

diag.add(diag::Diagnostic(

"Number of arguments does not match in the function call",

diag::Level::Error, diag::Stage::Semantic, {

diag::Label("(found: '" + fnd + "', expected: '" + org + "')",

{loc})

})

);

throw SemanticAbort();

}

for (size_t i=0; i<n_pos_args; i++) {

ASR::ttype_t *param_type = ASRUtils::expr_type(func->m_args[i]);

ASR::ttype_t *arg_type = ASRUtils::expr_type(args[i].m_value);

check_type_substitution(subs, param_type, arg_type, loc);

}

for (size_t i=0; i<func->n_restrictions; i++) {

ASR::Function_t* rt = ASR::down_cast<ASR::Function_t>(

func->m_restrictions[i]);

check_type_restriction(subs, rt_subs, rt, loc);

}

ASR::symbol_t *t = get_generic_function(subs, rt_subs, *func);

std::string new_call_name = (ASR::down_cast<ASR::Function_t>(t))->m_name;

// Currently ignoring keyword arguments for generic function calls

Vec<ASR::call_arg_t> new_args;

new_args.reserve(al, n_pos_args);

for (size_t i = 0; i<n_pos_args; i++) {

ASR::call_arg_t new_call_arg;

new_call_arg.m_value = args.p[i].m_value;

new_call_arg.loc = args.p[i].loc;

new_args.push_back(al, new_call_arg);

}

return make_call_helper(al, t, current_scope, new_args, new_call_name, loc);

}

if (args.size() != func->n_args) {

std::string fnd = std::to_string(args.size());

std::string org = std::to_string(func->n_args);

diag.add(diag::Diagnostic(

"Number of arguments does not match in the function call",

diag::Level::Error, diag::Stage::Semantic, {

diag::Label("(found: '" + fnd + "', expected: '" + org + "')",

{loc})

})

);

throw SemanticAbort();

}

if (ASR::down_cast<ASR::Function_t>(s)->m_return_var != nullptr) {

ASR::ttype_t *a_type = nullptr;

if( func->m_elemental && args.size() == 1 &&

ASRUtils::is_array(ASRUtils::expr_type(args[0].m_value)) ) {

a_type = ASRUtils::expr_type(args[0].m_value);

} else {

a_type = ASRUtils::expr_type(func->m_return_var);

a_type = handle_return_type(a_type, loc, args, func);

}

ASR::expr_t *value = nullptr;

if (ASRUtils::is_intrinsic_function2(func)) {

value = intrinsic_procedures.comptime_eval(call_name, al, loc, args);

}

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);