const std::string &runtime_library_dir,

const std::string &infile) {

std::string pycmd = "python " + runtime_library_dir + "/lpython_parser.py " + infile;

int err = std::system(pycmd.c_str());

if (err != 0) {

std::cerr << "The command '" << pycmd << "' failed." << std::endl;

return LFortran::Error();

}

std::string infile_ser = "ser.txt";

std::string input;

bool status = read_file(infile_ser, input);

if (!status) {

std::cerr << "The file '" << infile_ser << "' cannot be read." << std::endl;

return LFortran::Error();

}

LFortran::Python::AST::ast_t* ast = LFortran::Python::deserialize_ast(al, input);

return ast;

const std::string &runtime_library_dir, bool &ltypes, bool &numpy) {

ltypes = false;

numpy = false;

std::string input;

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 (filename == "numpy.py") {

filename_intrinsic = runtime_library_dir + "/lpython_intrinsic_numpy.py";

status = read_file(filename_intrinsic, input);

if (status) {

numpy = true;

return filename_intrinsic;

} else {

return LFortran::Error();

}

} else {

return LFortran::Error();

}

}

}

diag::Diagnostics &diag;

ASR::asr_t *tmp;

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;

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

CommonVisitor(Allocator &al, SymbolTable *symbol_table,

diag::Diagnostics &diagnostics, bool main_module,

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

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

ast_overload{ast_overload} {

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

}

if( v->type == ASR::symbolType::Variable ) {

ASR::Variable_t* v_var = ASR::down_cast<ASR::Variable_t>(v);

if( v_var->m_type == nullptr &&

v_var->m_intent == ASR::intentType::AssociateBlock ) {

return (ASR::asr_t*)(v_var->m_symbolic_value);

}

}

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

bool ltypes, numpy;

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

loc, true, rl_path,

ltypes, numpy,

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

);

LFORTRAN_ASSERT(!ltypes)

LFORTRAN_ASSERT(!numpy)

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)

|| ASR::is_a<ASR::Subroutine_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->scope[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;

}

// Convert Python AST type annotation to an ASR type

// Examples:

// i32, i64, f32, f64

// f64[256], i32[:]

ASR::ttype_t * ast_expr_to_asr_type(const Location &loc, const AST::expr_t &annotation) {

Vec<ASR::dimension_t> dims;

dims.reserve(al, 4);

std::string var_annotation;

if (AST::is_a<AST::Name_t>(annotation)) {

AST::Name_t *n = AST::down_cast<AST::Name_t>(&annotation);

var_annotation = n->m_id;

} else if (AST::is_a<AST::Subscript_t>(annotation)) {

AST::Subscript_t *s = AST::down_cast<AST::Subscript_t>(&annotation);

if (AST::is_a<AST::Name_t>(*s->m_value)) {

AST::Name_t *n = AST::down_cast<AST::Name_t>(s->m_value);

var_annotation = n->m_id;

} else {

throw SemanticError("Only Name in Subscript supported for now in annotation",

loc);

}

if (var_annotation == "tuple") {

Vec<ASR::ttype_t*> types;

types.reserve(al, 4);

if (AST::is_a<AST::Name_t>(*s->m_slice)) {

types.push_back(al, ast_expr_to_asr_type(loc, *s->m_slice));

} else if (AST::is_a<AST::Tuple_t>(*s->m_slice)) {

AST::Tuple_t *t = AST::down_cast<AST::Tuple_t>(s->m_slice);

for (size_t i=0; i<t->n_elts; i++) {

types.push_back(al, ast_expr_to_asr_type(loc, *t->m_elts[i]));

}

} else {

throw SemanticError("Only Name or Tuple in Subscript supported for now in `tuple` annotation",

loc);

}

ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_Tuple_t(al, loc,

types.p, types.size()));

return type;

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

if (AST::is_a<AST::Name_t>(*s->m_slice)) {

ASR::ttype_t *type = ast_expr_to_asr_type(loc, *s->m_slice);

return ASRUtils::TYPE(ASR::make_Set_t(al, loc, type));

} else {

throw SemanticError("Only Name in Subscript supported for now in `set`"

" annotation", loc);

}

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

ASR::ttype_t *type = nullptr;

if (AST::is_a<AST::Name_t>(*s->m_slice)) {

type = ast_expr_to_asr_type(loc, *s->m_slice);

} else if (AST::is_a<AST::Tuple_t>(*s->m_slice)) {

AST::Tuple_t *t = AST::down_cast<AST::Tuple_t>(s->m_slice);

type = ast_expr_to_asr_type(loc, *t->m_elts[0]);

} else {

throw SemanticError("Only Name or Tuple in Subscript supported for now in `list`"

" annotation", loc);

}

return type;

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

if (AST::is_a<AST::Tuple_t>(*s->m_slice)) {

AST::Tuple_t *t = AST::down_cast<AST::Tuple_t>(s->m_slice);

if (t->n_elts != 2) {

throw SemanticError("`dict` annotation must have 2 elements: types"

" of both keys and values", loc);

}

ASR::ttype_t *key_type = ast_expr_to_asr_type(loc, *t->m_elts[0]);

ASR::ttype_t *value_type = ast_expr_to_asr_type(loc, *t->m_elts[1]);

return ASRUtils::TYPE(ASR::make_Dict_t(al, loc, key_type, value_type));

} else {

throw SemanticError("`dict` annotation must have 2 elements: types of"

" both keys and values", loc);

}

} else {

ASR::dimension_t dim;

dim.loc = loc;

if (AST::is_a<AST::Slice_t>(*s->m_slice)) {

dim.m_start = nullptr;

dim.m_end = nullptr;

} else {

this->visit_expr(*s->m_slice);

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

if (ASR::is_a<ASR::ConstantInteger_t>(*value) || ASR::is_a<ASR::Var_t>(*value)) {

ASR::ttype_t *itype = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,

4, nullptr, 0));

dim.m_start = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantInteger_t(al, loc, 1, itype));

dim.m_end = value;

} else {

throw SemanticError("Only Integer, `:` or identifier in [] in Subscript supported for now in annotation",

loc);

}

}

dims.push_back(al, dim);

}

} else {

throw SemanticError("Only Name or Subscript supported for now in annotation of annotated assignment.",

loc);

}

ASR::ttype_t *type;

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,

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

} else {

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

}

return type;

}

ASR::expr_t *index_add_one(const Location &loc, ASR::expr_t *idx) {

// Add 1 to the index `idx`, assumes `idx` is of type Integer 4

ASR::expr_t *overloaded = nullptr;

ASR::expr_t *comptime_value = nullptr;

ASR::ttype_t *a_type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc,

4, nullptr, 0));

ASR::expr_t *constant_one = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantInteger_t(

al, loc, 1, a_type));

return ASRUtils::EXPR(ASR::make_BinOp_t(al, loc, idx,

ASR::binopType::Add, constant_one, a_type,

comptime_value, overloaded));

}

// Casts `right` if needed to the type of `left`

// (to be used during assignment, BinOp, or compare)

ASR::expr_t* implicitcast_helper(ASR::ttype_t *left_type, ASR::expr_t *right,

bool is_assign=false) {

ASR::ttype_t *right_type = ASRUtils::expr_type(right);

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

int lkind = ASR::down_cast<ASR::Integer_t>(left_type)->m_kind;

int rkind = ASR::down_cast<ASR::Integer_t>(right_type)->m_kind;

if ((is_assign && (lkind != rkind)) || (lkind > rkind)) {

return ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::IntegerToInteger,

left_type, nullptr));

}

} else if (ASRUtils::is_real(*left_type) && ASRUtils::is_real(*right_type)) {

bool is_l64 = ASR::down_cast<ASR::Real_t>(left_type)->m_kind == 8;

bool is_r64 = ASR::down_cast<ASR::Real_t>(right_type)->m_kind == 8;

if ((is_assign && (is_l64 != is_r64)) || (is_l64 && !is_r64)) {

return ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::RealToReal,

left_type, nullptr));

}

} else if (ASRUtils::is_complex(*left_type) && ASRUtils::is_complex(*right_type)) {

bool is_l64 = ASR::down_cast<ASR::Complex_t>(left_type)->m_kind == 8;

bool is_r64 = ASR::down_cast<ASR::Complex_t>(right_type)->m_kind == 8;

if ((is_assign && (is_l64 != is_r64)) || (is_l64 && !is_r64)) {

return ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::ComplexToComplex,

left_type, nullptr));

}

} else if (!is_assign && ASRUtils::is_real(*left_type) && ASRUtils::is_integer(*right_type)) {

return ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::IntegerToReal,

left_type, nullptr));

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

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

right->base.loc);

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

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

right->base.loc);

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

if (ASRUtils::is_real(*right_type)) {

return ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::RealToComplex,

left_type, nullptr));

} else if (ASRUtils::is_integer(*right_type)) {

return ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::IntegerToComplex,

left_type, nullptr));

} else {

std::string rtype = ASRUtils::type_to_str(right_type);

throw SemanticError("Casting " + rtype + " to complex is not Implemented",

right->base.loc);

}

}

return right;

}

void make_BinOp_helper(ASR::expr_t *left, ASR::expr_t *right,

ASR::binopType op, const Location &loc, bool floordiv) {

ASR::ttype_t *left_type = ASRUtils::expr_type(left);

ASR::ttype_t *right_type = ASRUtils::expr_type(right);

ASR::ttype_t *dest_type = nullptr;

ASR::expr_t *value = nullptr;

bool right_is_int = ASRUtils::is_character(*left_type) && ASRUtils::is_integer(*right_type);

bool left_is_int = ASRUtils::is_integer(*left_type) && ASRUtils::is_character(*right_type);

// Handle normal division in python with reals

if (op == ASR::binopType::Div) {

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

diag.add(diag::Diagnostic(

"Division is not supported for string type",

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

diag::Label("string not supported in division" ,

{left->base.loc, right->base.loc})

})

);

throw SemanticAbort();

}

// Floor div operation in python using (`//`)

if (floordiv) {

bool both_int = (ASRUtils::is_integer(*left_type) && ASRUtils::is_integer(*right_type));

if (both_int) {

dest_type = ASRUtils::TYPE(ASR::make_Integer_t(al,

loc, 4, nullptr, 0));

} else {

dest_type = ASRUtils::TYPE(ASR::make_Real_t(al,

loc, 8, nullptr, 0));

}

if (ASRUtils::is_real(*left_type)) {

left = ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, left->base.loc, left, ASR::cast_kindType::RealToInteger, dest_type,

value));

}

if (ASRUtils::is_real(*right_type)) {

right = ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::RealToInteger, dest_type,

value));

}

} else { // real divison in python using (`/`)

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

8, nullptr, 0));

if (ASRUtils::is_integer(*left_type)) {

left = ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, left->base.loc, left, ASR::cast_kindType::IntegerToReal, dest_type,

value));

}

if (ASRUtils::is_integer(*right_type)) {

right = ASR::down_cast<ASR::expr_t>(ASR::make_ImplicitCast_t(

al, right->base.loc, right, ASR::cast_kindType::IntegerToReal, dest_type,

value));

}

}

} else if((ASRUtils::is_integer(*left_type) || ASRUtils::is_real(*left_type) ||

ASRUtils::is_complex(*left_type)) &&

(ASRUtils::is_integer(*right_type) || ASRUtils::is_real(*right_type) ||

ASRUtils::is_complex(*right_type))) {

left = implicitcast_helper(ASRUtils::expr_type(right), left);

right = implicitcast_helper(ASRUtils::expr_type(left), right);

dest_type = ASRUtils::expr_type(left);

} else if ((right_is_int || left_is_int) && op == ASR::binopType::Mul) {

// string repeat

ASR::stropType ops = ASR::stropType::Repeat;

int64_t left_int = 0, right_int = 0, dest_len = 0;

if (right_is_int) {

ASR::Character_t *left_type2 = ASR::down_cast<ASR::Character_t>(left_type);

LFORTRAN_ASSERT(left_type2->n_dims == 0);

right_int = ASR::down_cast<ASR::ConstantInteger_t>(

ASRUtils::expr_value(right))->m_n;

dest_len = left_type2->m_len * right_int;

if (dest_len < 0) dest_len = 0;

dest_type = ASR::down_cast<ASR::ttype_t>(

ASR::make_Character_t(al, loc, left_type2->m_kind,

dest_len, nullptr, nullptr, 0));

} else if (left_is_int) {

ASR::Character_t *right_type2 = ASR::down_cast<ASR::Character_t>(right_type);

LFORTRAN_ASSERT(right_type2->n_dims == 0);

left_int = ASR::down_cast<ASR::ConstantInteger_t>(

ASRUtils::expr_value(left))->m_n;

dest_len = right_type2->m_len * left_int;

if (dest_len < 0) dest_len = 0;

dest_type = ASR::down_cast<ASR::ttype_t>(

ASR::make_Character_t(al, loc, right_type2->m_kind,

dest_len, nullptr, nullptr, 0));

}

if (ASRUtils::expr_value(left) != nullptr && ASRUtils::expr_value(right) != nullptr) {

char* str = right_is_int ? ASR::down_cast<ASR::ConstantString_t>(

ASRUtils::expr_value(left))->m_s :

ASR::down_cast<ASR::ConstantString_t>(

ASRUtils::expr_value(right))->m_s;

int64_t repeat = right_is_int ? right_int : left_int;

char* result;

std::ostringstream os;

std::fill_n(std::ostream_iterator<std::string>(os), repeat, std::string(str));

result = s2c(al, os.str());

LFORTRAN_ASSERT((int64_t)strlen(result) == dest_len)

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantString_t(

al, loc, result, dest_type));

}

tmp = ASR::make_StrOp_t(al, loc, left, ops, right, dest_type, value);

return;

} else if (ASRUtils::is_character(*left_type) && ASRUtils::is_character(*right_type)

&& op == ASR::binopType::Add) {

// string concat

ASR::stropType ops = ASR::stropType::Concat;

ASR::Character_t *left_type2 = ASR::down_cast<ASR::Character_t>(left_type);

ASR::Character_t *right_type2 = ASR::down_cast<ASR::Character_t>(right_type);

LFORTRAN_ASSERT(left_type2->n_dims == 0);

LFORTRAN_ASSERT(right_type2->n_dims == 0);

dest_type = ASR::down_cast<ASR::ttype_t>(

ASR::make_Character_t(al, loc, left_type2->m_kind,

left_type2->m_len + right_type2->m_len, nullptr, nullptr, 0));

if (ASRUtils::expr_value(left) != nullptr && ASRUtils::expr_value(right) != nullptr) {

char* left_value = ASR::down_cast<ASR::ConstantString_t>(

ASRUtils::expr_value(left))->m_s;

char* right_value = ASR::down_cast<ASR::ConstantString_t>(

ASRUtils::expr_value(right))->m_s;

char* result;

std::string result_s = std::string(left_value) + std::string(right_value);

result = s2c(al, result_s);

LFORTRAN_ASSERT((int64_t)strlen(result) == ASR::down_cast<ASR::Character_t>(dest_type)->m_len)

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantString_t(

al, loc, result, dest_type));

}

tmp = ASR::make_StrOp_t(al, loc, left, ops, right, dest_type,

value);

return;

} else if (ASRUtils::is_complex(*left_type) && ASRUtils::is_complex(*right_type)) {

dest_type = left_type;

} else if (ASRUtils::is_logical(*left_type) && ASRUtils::is_logical(*right_type)) {

dest_type = left_type;

} else {

std::string ltype = ASRUtils::type_to_str(ASRUtils::expr_type(left));

std::string rtype = ASRUtils::type_to_str(ASRUtils::expr_type(right));

diag.add(diag::Diagnostic(

"Not Implemented: type mismatch in binary operator; only Integer, Real, Complex,"

" Logical combinations and string concatenation/repetition are implemented for now.",

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

diag::Label("type mismatch (" + ltype + " and " + rtype + ")",

{left->base.loc, right->base.loc})

})

);

throw SemanticAbort();

}

// Check that the types are now the same

if (!ASRUtils::check_equal_type(ASRUtils::expr_type(left),

ASRUtils::expr_type(right))) {

std::string ltype = ASRUtils::type_to_str(ASRUtils::expr_type(left));

std::string rtype = ASRUtils::type_to_str(ASRUtils::expr_type(right));

diag.add(diag::Diagnostic(

"Type mismatch in binary operator, the types must be compatible",

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

diag::Label("type mismatch (" + ltype + " and " + rtype + ")",

{left->base.loc, right->base.loc})

})

);

throw SemanticAbort();

}

ASR::ttype_t* int_type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4, nullptr, 0));

// Now, compute the result of the binary operations

if (ASRUtils::expr_value(left) != nullptr && ASRUtils::expr_value(right) != nullptr) {

if (ASRUtils::is_integer(*dest_type)) {

int64_t left_value = ASR::down_cast<ASR::ConstantInteger_t>(

ASRUtils::expr_value(left))->m_n;

int64_t right_value = ASR::down_cast<ASR::ConstantInteger_t>(

ASRUtils::expr_value(right))->m_n;

int64_t result;

switch (op) {

case (ASR::binopType::Add): { result = left_value + right_value; break; }

case (ASR::binopType::Sub): { result = left_value - right_value; break; }

case (ASR::binopType::Mul): { result = left_value * right_value; break; }

case (ASR::binopType::Div): { result = left_value / right_value; break; }

case (ASR::binopType::Pow): { result = std::pow(left_value, right_value); break; }

default: { LFORTRAN_ASSERT(false); } // should never happen

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantInteger_t(

al, loc, result, dest_type));

}

else if (ASRUtils::is_real(*dest_type)) {

double left_value = ASR::down_cast<ASR::ConstantReal_t>(

ASRUtils::expr_value(left))->m_r;

double right_value = ASR::down_cast<ASR::ConstantReal_t>(

ASRUtils::expr_value(right))->m_r;

double result;

switch (op) {

case (ASR::binopType::Add): { result = left_value + right_value; break; }

case (ASR::binopType::Sub): { result = left_value - right_value; break; }

case (ASR::binopType::Mul): { result = left_value * right_value; break; }

case (ASR::binopType::Div): { result = left_value / right_value; break; }

case (ASR::binopType::Pow): { result = std::pow(left_value, right_value); break; }

default: { LFORTRAN_ASSERT(false); }

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantReal_t(

al, loc, result, dest_type));

}

else if (ASRUtils::is_complex(*dest_type)) {

ASR::ConstantComplex_t *left0 = ASR::down_cast<ASR::ConstantComplex_t>(

ASRUtils::expr_value(left));

ASR::ConstantComplex_t *right0 = ASR::down_cast<ASR::ConstantComplex_t>(

ASRUtils::expr_value(right));

std::complex<double> left_value(left0->m_re, left0->m_im);

std::complex<double> right_value(right0->m_re, right0->m_im);

std::complex<double> result;

switch (op) {

case (ASR::binopType::Add): { result = left_value + right_value; break; }

case (ASR::binopType::Sub): { result = left_value - right_value; break; }

case (ASR::binopType::Mul): { result = left_value * right_value; break; }

case (ASR::binopType::Div): { result = left_value / right_value; break; }

case (ASR::binopType::Pow): { result = std::pow(left_value, right_value); break; }

default: { LFORTRAN_ASSERT(false); }

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantComplex_t(al, loc,

std::real(result), std::imag(result), dest_type));

}

else if (ASRUtils::is_logical(*dest_type)) {

int8_t left_value = ASR::down_cast<ASR::ConstantLogical_t>(

ASRUtils::expr_value(left))->m_value;

int8_t right_value = ASR::down_cast<ASR::ConstantLogical_t>(

ASRUtils::expr_value(right))->m_value;

int8_t result;

switch (op) {

case (ASR::binopType::Add): { result = left_value + right_value; break; }

case (ASR::binopType::Sub): { result = left_value - right_value; break; }

case (ASR::binopType::Mul): { result = left_value * right_value; break; }

case (ASR::binopType::Pow): { result = std::pow(left_value, right_value); break; }

case (ASR::binopType::Div): { } // TODO: Handle division of logicals

default: { LFORTRAN_ASSERT(false); } // should never happen

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantInteger_t(

al, loc, result, int_type));

dest_type = int_type;

}

}

ASR::expr_t *overloaded = nullptr;

tmp = ASR::make_BinOp_t(al, loc, left, op, right, dest_type,

value, overloaded);

}

void visit_Name(const AST::Name_t &x) {

std::string name = x.m_id;

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

if (s) {

tmp = ASR::make_Var_t(al, x.base.base.loc, s);

} else {

throw SemanticError("Variable '" + name + "' not declared",

x.base.base.loc);

}

}

void visit_NamedExpr(const AST::NamedExpr_t &x) {

this->visit_expr(*x.m_target);

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

ASR::ttype_t *target_type = ASRUtils::expr_type(target);

this->visit_expr(*x.m_value);

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

ASR::ttype_t *value_type = ASRUtils::expr_type(value);

LFORTRAN_ASSERT(ASRUtils::check_equal_type(target_type, value_type));

tmp = ASR::make_NamedExpr_t(al, x.base.base.loc, target, value, value_type);

}

void visit_ConstantInt(const AST::ConstantInt_t &x) {

int64_t i = x.m_value;

ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_Integer_t(al, x.base.base.loc,

4, nullptr, 0));

tmp = ASR::make_ConstantInteger_t(al, x.base.base.loc, i, type);

}

void visit_ConstantFloat(const AST::ConstantFloat_t &x) {

double f = x.m_value;

ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_Real_t(al, x.base.base.loc,

8, nullptr, 0));

tmp = ASR::make_ConstantReal_t(al, x.base.base.loc, f, type);

}

void visit_ConstantComplex(const AST::ConstantComplex_t &x) {

double re = x.m_re, im = x.m_im;

ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_Complex_t(al, x.base.base.loc,

8, nullptr, 0));

tmp = ASR::make_ConstantComplex_t(al, x.base.base.loc, re, im, type);

}

void visit_ConstantStr(const AST::ConstantStr_t &x) {

char *s = x.m_value;

size_t s_size = std::string(s).size();

ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_Character_t(al, x.base.base.loc,

1, s_size, nullptr, nullptr, 0));

tmp = ASR::make_ConstantString_t(al, x.base.base.loc, s, type);

}

void visit_ConstantBool(const AST::ConstantBool_t &x) {

bool b = x.m_value;

ASR::ttype_t *type = ASRUtils::TYPE(ASR::make_Logical_t(al, x.base.base.loc,

1, nullptr, 0));

tmp = ASR::make_ConstantLogical_t(al, x.base.base.loc, b, type);

}

void visit_BoolOp(const AST::BoolOp_t &x) {

ASR::boolopType op;

if (x.n_values > 2) {

throw SemanticError("Only two operands supported for boolean operations",

x.base.base.loc);

}

this->visit_expr(*x.m_values[0]);

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

this->visit_expr(*x.m_values[1]);

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

switch (x.m_op) {

case (AST::boolopType::And): { op = ASR::boolopType::And; break; }

case (AST::boolopType::Or): { op = ASR::boolopType::Or; break; }

default : {

throw SemanticError("Boolean operator type not supported",

x.base.base.loc);

}

}

LFORTRAN_ASSERT(

ASRUtils::check_equal_type(ASRUtils::expr_type(lhs), ASRUtils::expr_type(rhs)));

ASR::expr_t *value = nullptr;

ASR::ttype_t *dest_type = ASRUtils::expr_type(lhs);

if (ASRUtils::expr_value(lhs) != nullptr && ASRUtils::expr_value(rhs) != nullptr) {

LFORTRAN_ASSERT(ASR::is_a<ASR::Logical_t>(*dest_type));

bool left_value = ASR::down_cast<ASR::ConstantLogical_t>(

ASRUtils::expr_value(lhs))->m_value;

bool right_value = ASR::down_cast<ASR::ConstantLogical_t>(

ASRUtils::expr_value(rhs))->m_value;

bool result;

switch (op) {

case (ASR::boolopType::And): { result = left_value && right_value; break; }

case (ASR::boolopType::Or): { result = left_value || right_value; break; }

default : {

throw SemanticError("Boolean operator type not supported",

x.base.base.loc);

}

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantLogical_t(

al, x.base.base.loc, result, dest_type));

}

tmp = ASR::make_BoolOp_t(al, x.base.base.loc, lhs, op, rhs, dest_type, value);

}

void visit_BinOp(const AST::BinOp_t &x) {

this->visit_expr(*x.m_left);

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

this->visit_expr(*x.m_right);

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

ASR::binopType op;

switch (x.m_op) {

case (AST::operatorType::Add) : { op = ASR::binopType::Add; break; }

case (AST::operatorType::Sub) : { op = ASR::binopType::Sub; break; }

case (AST::operatorType::Mult) : { op = ASR::binopType::Mul; break; }

case (AST::operatorType::Div) : { op = ASR::binopType::Div; break; }

case (AST::operatorType::FloorDiv) : {op = ASR::binopType::Div; break;}

case (AST::operatorType::Pow) : { op = ASR::binopType::Pow; break; }

default : {

throw SemanticError("Binary operator type not supported",

x.base.base.loc);

}

}

bool floordiv = (x.m_op == AST::operatorType::FloorDiv);

make_BinOp_helper(left, right, op, x.base.base.loc, floordiv);

}

void visit_UnaryOp(const AST::UnaryOp_t &x) {

this->visit_expr(*x.m_operand);

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

ASR::unaryopType op;

switch (x.m_op) {

case (AST::unaryopType::Invert) : { op = ASR::unaryopType::Invert; break; }

case (AST::unaryopType::Not) : { op = ASR::unaryopType::Not; break; }

case (AST::unaryopType::UAdd) : { op = ASR::unaryopType::UAdd; break; }

case (AST::unaryopType::USub) : { op = ASR::unaryopType::USub; break; }

default : {

throw SemanticError("Unary operator type not supported",

x.base.base.loc);

}

}

ASR::ttype_t *operand_type = ASRUtils::expr_type(operand);

ASR::ttype_t *logical_type = ASRUtils::TYPE(

ASR::make_Logical_t(al, x.base.base.loc, 4, nullptr, 0));

ASR::ttype_t *int_type = ASRUtils::TYPE(ASR::make_Integer_t(al, x.base.base.loc,

4, nullptr, 0));

ASR::expr_t *value = nullptr;

if (ASRUtils::expr_value(operand) != nullptr) {

if (ASRUtils::is_integer(*operand_type)) {

int64_t op_value = ASR::down_cast<ASR::ConstantInteger_t>(

ASRUtils::expr_value(operand))->m_n;

if (op == ASR::unaryopType::Not) {

bool b = (op_value == 0);

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantLogical_t(

al, x.base.base.loc, b, logical_type));

operand_type = logical_type;

} else {

int64_t result = 0;

switch (op) {

case (ASR::unaryopType::UAdd): { result = op_value; break; }

case (ASR::unaryopType::USub): { result = -op_value; break; }

case (ASR::unaryopType::Invert): { result = ~op_value; break; }

default: LFORTRAN_ASSERT(false); // should never happen

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantInteger_t(

al, x.base.base.loc, result, operand_type));

}

} else if (ASRUtils::is_real(*operand_type)) {

double op_value = ASR::down_cast<ASR::ConstantReal_t>(

ASRUtils::expr_value(operand))->m_r;

if (op == ASR::unaryopType::Not) {

bool b = (op_value == 0.0);

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantLogical_t(

al, x.base.base.loc, b, logical_type));

operand_type = logical_type;

} else {

double result = 0.0;

switch (op) {

case (ASR::unaryopType::UAdd): { result = op_value; break; }

case (ASR::unaryopType::USub): { result = -op_value; break; }

default: {

throw SemanticError("Bad operand type for unary " +

ASRUtils::unop_to_str(op) + ": " + ASRUtils::type_to_str(operand_type),

x.base.base.loc);

}

}

value = ASR::down_cast<ASR::expr_t>(ASR::make_ConstantReal_t(

al, x.base.base.loc, result, operand_type));

}

} else if (ASRUtils::is_logical(*operand_type)) {

bool op_value = ASR::down_cast<ASR::ConstantLogical_t>(

ASRUtils::expr_value(operand))->m_value;

if (op == ASR::unaryopType::Not) {

value = ASR::down_cast<ASR::expr_t>(

ASR::make_ConstantLogical_t(al, x.base.base.loc, !op_value, logical_type));

} else {

int8_t result = 0;

switch (op) {

case (ASR::unaryopType::UAdd): { result = +op_value; break; }

case (ASR::unaryopType::USub): { result = -op_value; break; }

case (ASR::unaryopType::Invert): { result = op_value ? -2 : -1; break; }

default : LFORTRAN_ASSERT(false); // should never happen

}

value = ASR::down_cast<ASR::expr_t>(

ASR::make_ConstantInteger_t(al, x.base.base.loc, result, int_type));

operand_type = int_type;

}

} else if (ASRUtils::is_complex(*operand_type)) {

ASR::ConstantComplex_t *c = ASR::down_cast<ASR::ConstantComplex_t>(

ASRUtils::expr_value(operand));

std::complex<double> op_value(c->m_re, c->m_im);

std::complex<double> result;

if (op == ASR::unaryopType::Not) {

bool b = (op_value.real() == 0.0 && op_value.imag() == 0.0);

value = ASR::down_cast<ASR::expr_t>(

ASR::make_ConstantLogical_t(al, x.base.base.loc, b, logical_type));

operand_type = logical_type;

} else {

switch (op) {

case (ASR::unaryopType::UAdd): { result = op_value; break; }

case (ASR::unaryopType::USub): { result = -op_value; break; }

default: {

throw SemanticError("Bad operand type for unary " +

ASRUtils::unop_to_str(op) + ": " + ASRUtils::type_to_str(operand_type),

x.base.base.loc);

}

}

value = ASR::down_cast<ASR::expr_t>(

ASR::make_ConstantComplex_t(al, x.base.base.loc,

std::real(result), std::imag(result), operand_type));

}

}

}

tmp = ASR::make_UnaryOp_t(al, x.base.base.loc, op, operand, operand_type,

value);

}

void visit_IfExp(const AST::IfExp_t &x) {

this->visit_expr(*x.m_test);

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

this->visit_expr(*x.m_body);

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

this->visit_expr(*x.m_orelse);

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

LFORTRAN_ASSERT(ASRUtils::check_equal_type(ASRUtils::expr_type(body),