std::string infile, LocationManager& lm) {

diag::Diagnostics diagnostics;

LCOMPILERS_ASSERT(asr_verify(u, true, diagnostics));

std::string modfile_binary = save_pycfile(u, lm);

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;

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

bool &lpython, bool& enum_py) {

lpython = false;

enum_py = false;

std::string file_path;

if( *(runtime_library_dir.rbegin()) == '/' ) {

file_path = runtime_library_dir + filename;

} else {

file_path = runtime_library_dir + "/" + filename;

}

bool status = read_file(file_path, input);

if (status) {

return file_path;

} else {

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

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

file_path = runtime_library_dir + "/lpython/" + filename;

status = read_file(file_path, input);

if (status) {

lpython = true;

return file_path;

} else {

return Error();

}

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

file_path = runtime_library_dir + "/lpython_intrinsic_" + filename;

status = read_file(file_path, input);

if (status) {

return file_path;

} else {

return Error();

}

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

enum_py = true;

return Error();

} else {

return Error();

}

}

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

bool& lpython, bool& enum_py) {

for (auto path: rl_path) {

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

if (rinfile.ok) {

infile = rinfile.result;

path_used = path;

return true;

}

}

return false;

Allocator& al) {

if( symtab == nullptr ) {

return ;

}

for( auto& itr: symtab->get_scope() ) {

if( ASR::is_a<ASR::ExternalSymbol_t>(*itr.second) ) {

ASR::ExternalSymbol_t* ext_sym = ASR::down_cast<ASR::ExternalSymbol_t>(itr.second);

mod_deps.push_back(al, ext_sym->m_module_name);

} else {

SymbolTable* sym_symtab = ASRUtils::symbol_symtab(itr.second);

fill_module_dependencies(sym_symtab, mod_deps, al);

}

}

ASR::Module_t* mod, std::vector<ASR::asr_t *> &tmp_vec) {

std::string mod_name = mod->m_name;

std::string g_func_name = mod_name + "global_stmts";

ASR::symbol_t *g_func = mod->m_symtab->get_symbol(g_func_name);

if (g_func && !scope->get_symbol(g_func_name)) {

ASR::symbol_t *es = ASR::down_cast<ASR::symbol_t>(

ASR::make_ExternalSymbol_t(al, mod->base.base.loc,

scope, s2c(al, g_func_name), g_func,

s2c(al, mod_name), nullptr, 0, s2c(al, g_func_name),

ASR::accessType::Public));

scope->add_symbol(g_func_name, es);

tmp_vec.push_back(ASRUtils::make_SubroutineCall_t_util(al, loc,

es, g_func, nullptr, 0, nullptr, nullptr, false));

}

diag::Diagnostics &diag;

ASR::asr_t *tmp;

/*

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

// Used to store the initializer for the global variables like list, ...

Vec<ASR::asr_t *> global_init;

Allocator &al;

LocationManager &lm;

SymbolTable *current_scope;

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

// This is the current module name that we are compiling from AST to ASR

// It is an empty string for main_module

std::string module_name;

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;

std::vector<std::string> import_paths;

/*

Vec<ASR::stmt_t*> *current_body;

ASR::expr_t* assign_asr_target;

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

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

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

std::map<std::string, std::string> context_map;

SetChar dependencies;

bool allow_implicit_casting;

// Stores the name of imported functions and the modules they are imported from

std::map<std::string, std::string> imported_functions;

bool using_args_attr = false;

std::map<std::string, std::string> numpy2lpythontypes = {

{"bool", "bool"},

{"bool_", "bool"},

{"int8", "i8"},

{"int16", "i16"},

{"int32", "i32"},

{"int64", "i64"},

{"uint8", "u8"},

{"uint16", "u16"},

{"uint32", "u32"},

{"uint64", "u64"},

{"float32", "f32"},

{"float64", "f64"},

{"float_", "f64"},

{"complex64", "c32"},

{"complex128", "c64"},

{"complex_", "c64"},

{"object", "T"}

};

CommonVisitor(Allocator &al, LocationManager &lm, SymbolTable *symbol_table,

diag::Diagnostics &diagnostics, bool main_module, std::string module_name,

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

std::vector<std::string> import_paths, bool allow_implicit_casting_)

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

ast_overload{ast_overload}, parent_dir{parent_dir}, import_paths{import_paths},

current_body{nullptr}, assign_asr_target{nullptr}, allow_implicit_casting{allow_implicit_casting_} {

current_module_dependencies.reserve(al, 4);

global_init.reserve(al, 1);

}

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

LCOMPILERS_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 lpython, enum_py, copy, sympy;

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

loc, diag, lm, true, paths,

lpython, enum_py, copy, sympy,

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

allow_implicit_casting);

LCOMPILERS_ASSERT(!lpython && !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);

std::string sym = fn_name;

ASR::symbol_t *v = nullptr;

if( current_scope->get_symbol(sym) == nullptr ) {

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

);

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

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

} else {

v = current_scope->get_symbol(sym);

}

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

return v;

}

void handle_builtin_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 handle_symbolic_attribute(ASR::expr_t *s, std::string attr_name,

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

tmp = attr_handler.get_symbolic_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, dependencies,

current_module_dependencies);

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

LCOMPILERS_ASSERT(expr_duplicator.success);

arg_replacer.current_expr = &expri_copy;

arg_replacer.replace_expr(expri_copy);

exprs[i] = expri_copy;

}

}

}

void fill_new_dims(ASR::Array_t* t, const std::vector<ASR::expr_t*>& func_calls,

Vec<ASR::dimension_t>& new_dims) {

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

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

ASR::dimension_t new_dim;

if (func_calls[i] != nullptr) {

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

} else {

new_dims.push_back(al, t->m_dims[j]);

}

}

}

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::Allocatable: {

ASR::Allocatable_t* allocatable_t = ASR::down_cast<ASR::Allocatable_t>(return_type);

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

ASRUtils::type_get_past_allocatable(

ASRUtils::type_get_past_pointer(

handle_return_type(allocatable_t->m_type, loc, args, f)))));

}

case ASR::ttypeType::Pointer: {

ASR::Pointer_t* pointer_t = ASR::down_cast<ASR::Pointer_t>(return_type);

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

ASRUtils::type_get_past_allocatable(

ASRUtils::type_get_past_pointer(

handle_return_type(pointer_t->m_type, loc, args, f)))));

}

case ASR::ttypeType::Array: {

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

ASR::ttype_t* t_m_type = handle_return_type(t->m_type, loc, args, f);

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;

fill_new_dims(t, func_calls, new_dims);

return ASRUtils::make_Array_t_util(al, loc, t_m_type, new_dims.p, new_dims.size());

}

case ASR::ttypeType::String: {

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

func_calls.push_back(t->m_len);

fix_exprs_ttype_t(func_calls, args, f);

ASR::expr_t* a_len = func_calls[0] ? func_calls[0] : t->m_len;

/*if( func_calls[0] ) {*/

/* diag::Diagnostics diags;*/

/* a_len = ASRUtils::extract_len<SemanticAbort>(func_calls[0], loc, diags);*/

/*}*/

return ASRUtils::TYPE(ASRUtils::make_Allocatable_t_util(al, loc, ASRUtils::TYPE(ASR::make_String_t(al, loc, t->m_kind,

a_len, ASR::string_length_kindType::DeferredLength, ASR::string_physical_typeType::DescriptorString))));

}

/*case ASR::ttypeType::StructType: {*/

/* ASR::StructType_t* struct_t_type = ASR::down_cast<ASR::StructType_t>(return_type);*/

/* ASR::symbol_t *sym = struct_t_type->m_derived_type;*/

/* ASR::symbol_t *es_s = current_scope->resolve_symbol(*/

/* ASRUtils::symbol_name(sym));*/

/* if (es_s == nullptr) {*/

/* ASR::Struct_t *st = ASR::down_cast<ASR::Struct_t>(sym);*/

/* ASR::Module_t* sym_module = ASRUtils::get_sym_module(sym);*/

/* LCOMPILERS_ASSERT(sym_module != nullptr);*/

/* std::string st_name = "1_" + std::string(st->m_name);*/

/* if (current_scope->get_symbol(st_name)) {*/

/* sym = current_scope->get_symbol(st_name);*/

/* } else {*/

/* sym = ASR::down_cast<ASR::symbol_t>(ASR::make_ExternalSymbol_t(*/

/* al, st->base.base.loc, current_scope, s2c(al, st_name),*/

/* sym, sym_module->m_name, nullptr, 0, st->m_name,*/

/* ASR::accessType::Public));*/

/* current_scope->add_symbol(st_name, sym);*/

/* }*/

/* } else {*/

/* sym = es_s;*/

/* }*/

/* return ASRUtils::make_StructType_t_util(al, loc, sym);*/

/*}*/

default: {

return return_type;

}

}

return nullptr;

}

void visit_AsyncFunctionDef(const AST::AsyncFunctionDef_t &x){

throw SemanticError("The `async` keyword is currently not supported", x.base.base.loc);

}

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

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

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

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

arg.loc.first = -1;

arg.loc.last = -1;

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 < ASRUtils::get_FunctionType(orig_func)->n_restrictions; i++ ) {

ASR::symbol_t* rt = ASRUtils::get_FunctionType(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) {

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

}

// Filling missing arguments with their defaults passed in function definition (if present).

std::string missed_args_names;

size_t missed_args_count =0;

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

if(call_args_vec.p[i].m_value == nullptr){

ASR::Variable_t* var = ASRUtils::EXPR2VAR(orig_func->m_args[i]);

if (var->m_symbolic_value == nullptr){

missed_args_names+="'" + (std::string) var->m_name + "' and ";

missed_args_count++;

} else {

call_args_vec.p[i].m_value = var->m_symbolic_value;

}

}

}

if(missed_args_count > 0){

missed_args_names = missed_args_names.substr(0,missed_args_names.length() - 5);

diag.add(diag::Diagnostic(

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

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

diag::Label("missing " + std::to_string(missed_args_count) + " required arguments :" + missed_args_names,

{call_loc})

})

);

throw SemanticAbort();

}

return true;

}

int64_t find_argument_position_from_name(ASR::Struct_t* orig_struct, std::string arg_name) {

for( size_t i = 0; i < orig_struct->n_members; i++ ) {

std::string original_arg_name = std::string(orig_struct->m_members[i]);

if( original_arg_name == arg_name ) {

return i;

}

}

return -1;

}

void 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,

ASR::Struct_t* orig_struct, const Location &loc) {

LCOMPILERS_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_struct, arg_name);

if( arg_pos == -1 ) {

throw SemanticError("Member '" + arg_name + "' not found in struct", kwargs[i].loc);

} else if (arg_pos >= (int64_t)call_args_vec.size()) {

throw SemanticError("Not enough arguments to " + std::string(orig_struct->m_name)

+ "(), expected " + std::to_string(orig_struct->n_members), loc);

}

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

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

+ arg_name + "'", kwargs[i].loc);

}

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

call_args_vec.p[arg_pos].m_value = expr;

}

}

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,

bool check_type_equality=true) {

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

ASR::ttype_t* left_type = ASRUtils::expr_type(m_args[i]);

ASR::ttype_t* right_type = ASRUtils::expr_type(c_arg.m_value);

if ( ASR::is_a<ASR::StructType_t>(*left_type) && ASR::is_a<ASR::StructType_t>(*right_type) ) {

ASR::Struct_t *l2_type =

ASR::down_cast<ASR::Struct_t>(ASRUtils::get_struct_sym_from_struct_expr(m_args[i]));

ASR::Struct_t *r2_type =

ASR::down_cast<ASR::Struct_t>(ASRUtils::get_struct_sym_from_struct_expr(c_arg.m_value));

if ( ASRUtils::is_derived_type_similar(l2_type, r2_type) ) {

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

check_type_equality = false;

} else {

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

}

} else {

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

}

if( check_type_equality && !ASRUtils::check_equal_type(left_type, right_type, m_args[i], c_arg.m_value) ) {

std::string ltype = ASRUtils::type_to_str_python_expr(left_type, m_args[i]);

std::string rtype = ASRUtils::type_to_str_python_expr(right_type, c_arg.m_value);

diag.add(diag::Diagnostic(

"Type mismatch in procedure call; the types must be compatible",

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

diag::Label("type mismatch (passed argument type is " + rtype + " but required type is " + ltype + ")",

{ c_arg.loc, left_type->base.loc})

})

);

throw SemanticAbort();

}

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, ASR::symbol_t*& type_decl,

AST::expr_t** m_args=nullptr, [[maybe_unused]] size_t n_args=0,

bool raise_error=true, ASR::abiType abi=ASR::abiType::Source,

bool is_argument=false) {

ASR::ttype_t* type = nullptr;

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

type = ASRUtils::TYPE(ASR::make_TypeParameter_t(al, loc, type_param->m_param));

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

}

} else {

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

if( der_sym ) {

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

type_decl = der_sym;

type = ASRUtils::make_StructType_t_util(al, loc, s, true);

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

type_decl = der_sym;

type = ASRUtils::get_union_type(al, loc, ASRUtils::symbol_get_past_external(der_sym));

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

}

}

}

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

type = ASRUtils::TYPE(ASRUtils::make_Allocatable_t_util(al ,loc, ASRUtils::TYPE(ASR::make_String_t(al, loc, 1, nullptr,

ASR::string_length_kindType::DeferredLength, ASR::string_physical_typeType::DescriptorString))));

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

type = ASRUtils::make_Array_t_util(al, loc, type, dims.p, dims.size(), abi, is_argument);

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

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

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

LCOMPILERS_ASSERT(n_args == 1);

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

bool is_allocatable = false, is_const = false;

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

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

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

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

}

if( !type && raise_error ) {

if (var_annotation == "int") {

std::string msg = "Hint: Use i8, i16, i32 or i64 for now. ";

diag.add(diag::Diagnostic(

var_annotation + " type is not supported yet. ",

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

diag::Label(msg, {loc})

})

);

throw SemanticAbort();

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

std::string msg = "Hint: Use f32 or f64 for now. ";

diag.add(diag::Diagnostic(

var_annotation + " type is not supported yet. ",

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

diag::Label(msg, {loc})

})

);

throw SemanticAbort();

} else {

throw SemanticError("The type '" + var_annotation+"' is undeclared.", loc);

}

}

return type;

}

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, loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)mfn,

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

ASR::accessType::Public

);

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

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

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

ASR::Struct_t *st = ASR::down_cast<ASR::Struct_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, loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)st,

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

ASR::accessType::Public

);

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

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

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

ASR::Enum_t *et = ASR::down_cast<ASR::Enum_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, loc,

/* a_symtab */ current_scope,

/* a_name */ cname,

(ASR::symbol_t*)et,

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

ASR::accessType::Public

);

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

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

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

ASR::Union_t *ut = ASR::down_cast<ASR::Union_t>(t);

Str name;