#include <fstream>

#include <iostream>

#include <map>

#include <set>

#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/pass/global_stmts.h>

#include <libasr/pass/intrinsic_function_registry.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 LCompilers::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::Integer, ASR::ttypeType::UnsignedInteger), ASR::cast_kindType::IntegerToUnsignedInteger},

{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},

{std::make_pair(ASR::ttypeType::UnsignedInteger, ASR::ttypeType::Integer), ASR::cast_kindType::UnsignedIntegerToInteger},

};

// 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) {

}

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

}

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

ASR::ttype_t* dest, Allocator& al,

const Location& loc) {

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

}

// TODO: Fix loc

return ASRUtils::EXPR(ASRUtils::make_Cast_t_value(al, loc, expr,

cast_kind, dest));

}

}

int save_pyc_files(const ASR::TranslationUnit_t &u,

}

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

}

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

}

ASR::TranslationUnit_t* compile_module_till_asr(Allocator& al,

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

const Location &loc, diag::Diagnostics &diagnostics, LocationManager &lm,

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

bool allow_implicit_casting) {

{

LocationManager::FileLocations fl;

fl.in_filename = infile;

lm.files.push_back(fl);

std::string input = read_file(infile);

lm.file_ends.push_back(lm.file_ends.back() + input.size());

lm.init_simple(input);

}

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

diagnostics, lm.file_ends.end()[-2], false);

if (!r.ok) {

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

}

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

// Convert the module from AST to ASR

CompilerOptions compiler_options;

compiler_options.disable_main = true;

compiler_options.symtab_only = false;

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

diagnostics, compiler_options, false, infile, allow_implicit_casting);

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

if (!r2.ok) {

LCOMPILERS_ASSERT(diagnostics.has_error())

return nullptr; // Error

}

return r2.result;

}

void fill_module_dependencies(SymbolTable* symtab, SetChar& mod_deps,

}

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

const std::string &module_name,

const Location &loc, diag::Diagnostics &diagnostics,

LocationManager &lm, bool intrinsic,

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

bool &lpython, bool& enum_py, bool& copy,

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

bool allow_implicit_casting) {

lpython = false;

enum_py = false;

copy = false;

if( module_name == "copy" ) {

copy = true;

return nullptr;

}

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

}

}

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

std::string module_dir_name = "";

bool found = set_module_path(infile0c, rl_path, infile,

path_used, input, lpython, enum_py);

if( !found ) {

input.clear();

found = set_module_path(infile0, rl_path, infile,

path_used, input, lpython, enum_py);

} else {

mod1 = load_pycfile(al, input, false);

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

diag::Diagnostics diagnostics;

LCOMPILERS_ASSERT(asr_verify(*mod1, true, diagnostics));

compile_module = false;

}

if( enum_py ) {

return nullptr;

}

if (!found) {

err("Could not find the module '" + module_name + "'. If an import path "

"is available, please use the `-I` option to specify it", loc);

}

if (lpython) return nullptr;

if( compile_module ) {

diagnostics.add(diag::Diagnostic(

"The module '" + module_name + "' located in " + infile +" cannot be loaded",

diag::Level::Warning, diag::Stage::Semantic, {

diag::Label("imported here", {loc})

})

);

mod1 = compile_module_till_asr(al, rl_path, infile, loc, diagnostics,

lm, err, allow_implicit_casting);

if (mod1 == nullptr) {

throw SemanticAbort();

} else {

diagnostics.diagnostics.pop_back();

}

}

// insert into `symtab`

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

if (module_name == "__init__") {

// remove `__init__.py`

module_dir_name = infile.substr(0, infile.find_last_of('/'));

// assign module directory name

module_dir_name = module_dir_name.substr(module_dir_name.find_last_of('/') + 1);

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

} else {

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;

} else if (a_name == module_dir_name) {

a_mod->m_name = s2c(al, module_dir_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 (ASRUtils::get_FunctionType(s)->m_abi == ASR::abiType::Source) {

ASRUtils::get_FunctionType(s)->m_abi = ASR::abiType::Intrinsic;

}

if (s->n_body == 0) {

std::string name = s->m_name;

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

ASRUtils::get_FunctionType(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, bool skip_current_scope_check=false) {

new_sym_name = ASRUtils::get_mangled_name(m, new_sym_name);

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 '" + std::string(m->m_name) + "'",

loc);

}

if (!skip_current_scope_check &&

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

throw SemanticError(new_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::StructType_t>(*t)) {

ASR::StructType_t *st = ASR::down_cast<ASR::StructType_t>(t);

// `st` is the StructType 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 *est = ASR::make_ExternalSymbol_t(

al, st->base.base.loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)st,

m->m_name, nullptr, 0, st->m_name,

ASR::accessType::Public

);

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

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

ASR::EnumType_t *et = ASR::down_cast<ASR::EnumType_t>(t);

Str name;

name.from_str(al, new_sym_name);

char *cname = name.c_str(al);

ASR::asr_t *est = ASR::make_ExternalSymbol_t(

al, et->base.base.loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)et,

m->m_name, nullptr, 0, et->m_name,

ASR::accessType::Public

);

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

} 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 if (ASR::is_a<ASR::ExternalSymbol_t>(*t)) {

ASR::ExternalSymbol_t *es = ASR::down_cast<ASR::ExternalSymbol_t>(t);

SymbolTable *symtab = current_scope;

// while (symtab->parent != nullptr) symtab = symtab->parent;

ASR::symbol_t *sym = symtab->resolve_symbol(es->m_module_name);

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

return import_from_module(al, m, symtab, es->m_module_name,

cur_sym_name, new_sym_name, loc);

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

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

std::string mangled_cur_sym_name = ASRUtils::get_mangled_name(mt, new_sym_name);

if( cur_sym_name == mangled_cur_sym_name ) {

throw SemanticError("Importing modules isn't supported yet.", loc);

}

return import_from_module(al, mt, current_scope, std::string(mt->m_name),

cur_sym_name, new_sym_name, loc);

} else {

throw SemanticError("Only Subroutines, Functions, StructType, Variables and "

"ExternalSymbol are currently supported in 'import'", loc);

}

LCOMPILERS_ASSERT(false);

return nullptr;

}

template <class Struct>

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