diff --git a/src/libasr/ASR.asdl b/src/libasr/ASR.asdl index 679c43ea98..6ee1b65dfe 100644 --- a/src/libasr/ASR.asdl +++ b/src/libasr/ASR.asdl @@ -15,7 +15,7 @@ symbol | GenericProcedure(symbol_table parent_symtab, identifier name, symbol* procs, access access) | CustomOperator(symbol_table parent_symtab, identifier name, symbol* procs, access access) | ExternalSymbol(symbol_table parent_symtab, identifier name, symbol external, identifier module_name, identifier* scope_names, identifier original_name, access access) - | StructType(symbol_table symtab, identifier name, identifier* dependencies, identifier* members, abi abi, access access, bool is_packed, bool is_abstract, call_arg* initializers, expr? alignment, symbol? parent) + | Struct(symbol_table symtab, identifier name, identifier* dependencies, identifier* members, abi abi, access access, bool is_packed, bool is_abstract, call_arg* initializers, expr? alignment, symbol? parent) | EnumType(symbol_table symtab, identifier name, identifier* dependencies, identifier* members, abi abi, access access, enumtype enum_value_type, ttype type, symbol? parent) | UnionType(symbol_table symtab, identifier name, identifier* dependencies, identifier* members, abi abi, access access, call_arg* initializers, symbol? parent) | Variable(symbol_table parent_symtab, identifier name, identifier* dependencies, intent intent, expr? symbolic_value, expr? value, storage_type storage, ttype type, symbol? type_declaration, abi abi, access access, presence presence, bool value_attr) @@ -85,7 +85,7 @@ expr | IntrinsicArrayFunction(int arr_intrinsic_id, expr* args, int overload_id, ttype? type, expr? value) | IntrinsicImpureFunction(int impure_intrinsic_id, expr* args, int overload_id, ttype? type, expr? value) | TypeInquiry(int inquiry_id, ttype arg_type, expr? arg, ttype type, expr value) - | StructTypeConstructor(symbol dt_sym, call_arg* args, ttype type, expr? value) + | StructConstructor(symbol dt_sym, call_arg* args, ttype type, expr? value) | EnumTypeConstructor(symbol dt_sym, expr* args, ttype type, expr? value) | UnionTypeConstructor(symbol dt_sym, expr* args, ttype type, expr? value) | ImpliedDoLoop(expr* values, expr var, expr start, expr end, expr? increment, ttype type, expr? value) @@ -199,7 +199,7 @@ ttype | Set(ttype type) | List(ttype type) | Tuple(ttype* type) - | Struct(symbol derived_type) + | StructType(symbol derived_type) | Enum(symbol enum_type) | Union(symbol union_type) | Class(symbol class_type) diff --git a/src/libasr/asr_utils.cpp b/src/libasr/asr_utils.cpp index 009076b33b..f8c183f2e8 100644 --- a/src/libasr/asr_utils.cpp +++ b/src/libasr/asr_utils.cpp @@ -414,8 +414,8 @@ void set_intrinsic(ASR::symbol_t* sym) { func_sym_type->m_abi = ASR::abiType::Intrinsic; break; } - case ASR::symbolType::StructType: { - ASR::StructType_t* derived_type_sym = ASR::down_cast(sym); + case ASR::symbolType::Struct: { + ASR::Struct_t* derived_type_sym = ASR::down_cast(sym); derived_type_sym->m_abi = ASR::abiType::Intrinsic; break; } @@ -467,8 +467,8 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc, ASR::asr_t* v_var, ASR::symbol_t *v, ASR::symbol_t* member, SymbolTable* current_scope) { member = ASRUtils::symbol_get_past_external(member); - if (ASR::is_a(*member)) { - ASR::StructType_t* member_variable = ASR::down_cast(member); + if (ASR::is_a(*member)) { + ASR::Struct_t* member_variable = ASR::down_cast(member); ASR::symbol_t *mem_es = nullptr; std::string mem_name = "1_" + std::string(ASRUtils::symbol_name(member)); if (current_scope->resolve_symbol(mem_name)) { @@ -480,7 +480,7 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc, nullptr, 0, member_variable->m_name, ASR::accessType::Public)); current_scope->add_symbol(mem_name, mem_es); } - ASR::ttype_t* member_type = ASRUtils::TYPE(ASR::make_Struct_t(al, + ASR::ttype_t* member_type = ASRUtils::TYPE(ASR::make_StructType_t(al, member_variable->base.base.loc, mem_es)); return ASR::make_StructInstanceMember_t(al, loc, ASRUtils::EXPR(v_var), mem_es, ASRUtils::fix_scoped_type(al, member_type, current_scope), nullptr); @@ -493,8 +493,8 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc, ASR::dimension_t* m_dims = nullptr; size_t n_dims = ASRUtils::extract_dimensions_from_ttype(member_type, m_dims); switch( member_type_->type ) { - case ASR::ttypeType::Struct: { - ASR::Struct_t* der = ASR::down_cast(member_type_); + case ASR::ttypeType::StructType: { + ASR::StructType_t* der = ASR::down_cast(member_type_); std::string der_type_name = ASRUtils::symbol_name(der->m_derived_type); ASR::symbol_t* der_type_sym = current_scope->resolve_symbol(der_type_name); if( der_type_sym == nullptr ) { @@ -505,9 +505,9 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc, ASR::ExternalSymbol_t* m_ext = ASR::down_cast(m_external); m_external = m_ext->m_external; module_name = m_ext->m_module_name; - } else if( ASR::is_a(*m_external) ) { + } else if( ASR::is_a(*m_external) ) { ASR::symbol_t* asr_owner = ASRUtils::get_asr_owner(m_external); - if( ASR::is_a(*asr_owner) || + if( ASR::is_a(*asr_owner) || ASR::is_a(*asr_owner) ) { module_name = ASRUtils::symbol_name(asr_owner); } @@ -543,10 +543,10 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc, } else { der_ext = current_scope->get_symbol(mangled_name); } - ASR::asr_t* der_new = ASR::make_Struct_t(al, loc, der_ext); + ASR::asr_t* der_new = ASR::make_StructType_t(al, loc, der_ext); member_type_ = ASRUtils::TYPE(der_new); } else if(ASR::is_a(*der_type_sym)) { - member_type_ = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, der_type_sym)); + member_type_ = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, der_type_sym)); } member_type = ASRUtils::make_Array_t_util(al, loc, member_type_, m_dims, n_dims); @@ -586,13 +586,13 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, const std::function err) { ASR::ttype_t *left_type = ASRUtils::expr_type(left); ASR::ttype_t *right_type = ASRUtils::expr_type(right); - ASR::StructType_t *left_struct = nullptr; - if ( ASR::is_a(*left_type) ) { - left_struct = ASR::down_cast( - ASRUtils::symbol_get_past_external(ASR::down_cast( + ASR::Struct_t *left_struct = nullptr; + if ( ASR::is_a(*left_type) ) { + left_struct = ASR::down_cast( + ASRUtils::symbol_get_past_external(ASR::down_cast( left_type)->m_derived_type)); } else if ( ASR::is_a(*left_type) ) { - left_struct = ASR::down_cast( + left_struct = ASR::down_cast( ASRUtils::symbol_get_past_external(ASR::down_cast( left_type)->m_class_type)); } @@ -666,8 +666,8 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, ASR::dimension_t* m_dims = nullptr; size_t n_dims = ASRUtils::extract_dimensions_from_ttype(return_type, m_dims); return_type = ASRUtils::type_get_past_array(return_type); - if( ASR::is_a(*return_type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(return_type); + if( ASR::is_a(*return_type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(return_type); if( curr_scope->get_counter() != ASRUtils::symbol_parent_symtab(struct_t->m_derived_type)->get_counter() && !curr_scope->resolve_symbol(ASRUtils::symbol_name(struct_t->m_derived_type)) ) { @@ -677,7 +677,7 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, ASRUtils::symbol_name(ASRUtils::get_asr_owner(struct_t->m_derived_type)), nullptr, 0, ASRUtils::symbol_name(struct_t->m_derived_type), ASR::accessType::Public))); } - return_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, + return_type = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, curr_scope->resolve_symbol(ASRUtils::symbol_name(struct_t->m_derived_type)))); if( is_array ) { return_type = ASRUtils::make_Array_t_util(al, loc, return_type, m_dims, n_dims); @@ -757,8 +757,8 @@ void process_overloaded_unary_minus_function(ASR::symbol_t* proc, ASR::expr_t* o ASR::dimension_t* m_dims = nullptr; size_t n_dims = ASRUtils::extract_dimensions_from_ttype(return_type, m_dims); return_type = ASRUtils::type_get_past_array(return_type); - if( ASR::is_a(*return_type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(return_type); + if( ASR::is_a(*return_type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(return_type); if( curr_scope->get_counter() != ASRUtils::symbol_parent_symtab(struct_t->m_derived_type)->get_counter() && !curr_scope->resolve_symbol(ASRUtils::symbol_name(struct_t->m_derived_type)) ) { @@ -768,7 +768,7 @@ void process_overloaded_unary_minus_function(ASR::symbol_t* proc, ASR::expr_t* o ASRUtils::symbol_name(ASRUtils::get_asr_owner(struct_t->m_derived_type)), nullptr, 0, ASRUtils::symbol_name(struct_t->m_derived_type), ASR::accessType::Public))); } - return_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, + return_type = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, curr_scope->resolve_symbol(ASRUtils::symbol_name(struct_t->m_derived_type)))); if( is_array ) { return_type = ASRUtils::make_Array_t_util( @@ -797,14 +797,14 @@ bool use_overloaded_unary_minus(ASR::expr_t* operand, ASR::ttype_t *operand_type = ASRUtils::expr_type(operand); ASR::symbol_t* sym = curr_scope->resolve_symbol("~sub"); if( !sym ) { - if( ASR::is_a(*operand_type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(operand_type); + if( ASR::is_a(*operand_type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(operand_type); ASR::symbol_t* struct_t_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); - if( ASR::is_a(*struct_t_sym) ) { - ASR::StructType_t* struct_type_t = ASR::down_cast(struct_t_sym); + if( ASR::is_a(*struct_t_sym) ) { + ASR::Struct_t* struct_type_t = ASR::down_cast(struct_t_sym); sym = struct_type_t->m_symtab->resolve_symbol("~sub"); while( sym == nullptr && struct_type_t->m_parent != nullptr ) { - struct_type_t = ASR::down_cast( + struct_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_type_t->m_parent)); sym = struct_type_t->m_symtab->resolve_symbol("~sub"); } @@ -850,7 +850,7 @@ bool use_overloaded_unary_minus(ASR::expr_t* operand, } bool is_op_overloaded(ASR::binopType op, std::string& intrinsic_op_name, - SymbolTable* curr_scope, ASR::StructType_t* left_struct) { + SymbolTable* curr_scope, ASR::Struct_t* left_struct) { bool result = true; switch(op) { case ASR::binopType::Add: { @@ -972,14 +972,14 @@ bool use_overloaded_assignment(ASR::expr_t* target, ASR::expr_t* value, ASR::symbol_t* sym = curr_scope->resolve_symbol("~assign"); ASR::expr_t* expr_dt = nullptr; if( !sym ) { - if( ASR::is_a(*target_type) ) { - ASR::StructType_t* target_struct = ASR::down_cast( - ASRUtils::symbol_get_past_external(ASR::down_cast(target_type)->m_derived_type)); + if( ASR::is_a(*target_type) ) { + ASR::Struct_t* target_struct = ASR::down_cast( + ASRUtils::symbol_get_past_external(ASR::down_cast(target_type)->m_derived_type)); sym = target_struct->m_symtab->resolve_symbol("~assign"); expr_dt = target; - } else if( ASR::is_a(*value_type) ) { - ASR::StructType_t* value_struct = ASR::down_cast( - ASRUtils::symbol_get_past_external(ASR::down_cast(value_type)->m_derived_type)); + } else if( ASR::is_a(*value_type) ) { + ASR::Struct_t* value_struct = ASR::down_cast( + ASRUtils::symbol_get_past_external(ASR::down_cast(value_type)->m_derived_type)); sym = value_struct->m_symtab->resolve_symbol("~assign"); expr_dt = value; } @@ -1074,9 +1074,9 @@ bool use_overloaded_file_read_write(std::string &read_write, Vec a ASR::symbol_t* sym = curr_scope->resolve_symbol(read_write); ASR::expr_t* expr_dt = nullptr; if( sym == nullptr ) { - if( ASR::is_a(*arg_type) ) { - ASR::StructType_t* arg_struct = ASR::down_cast( - ASRUtils::symbol_get_past_external(ASR::down_cast(arg_type)->m_derived_type)); + if( ASR::is_a(*arg_type) ) { + ASR::Struct_t* arg_struct = ASR::down_cast( + ASRUtils::symbol_get_past_external(ASR::down_cast(arg_type)->m_derived_type)); sym = arg_struct->m_symtab->resolve_symbol(read_write); expr_dt = args[0]; } @@ -1120,13 +1120,13 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, const std::function err) { ASR::ttype_t *left_type = ASRUtils::expr_type(left); ASR::ttype_t *right_type = ASRUtils::expr_type(right); - ASR::StructType_t *left_struct = nullptr; - if ( ASR::is_a(*left_type) ) { - left_struct = ASR::down_cast( - ASRUtils::symbol_get_past_external(ASR::down_cast( + ASR::Struct_t *left_struct = nullptr; + if ( ASR::is_a(*left_type) ) { + left_struct = ASR::down_cast( + ASRUtils::symbol_get_past_external(ASR::down_cast( left_type)->m_derived_type)); } else if ( ASR::is_a(*left_type) ) { - left_struct = ASR::down_cast( + left_struct = ASR::down_cast( ASRUtils::symbol_get_past_external(ASR::down_cast( left_type)->m_class_type)); } @@ -1157,9 +1157,9 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, if( (left_arg_type->type == left_type->type && right_arg_type->type == right_type->type) || (ASR::is_a(*left_arg_type) && - ASR::is_a(*left_type)) + ASR::is_a(*left_type)) || (ASR::is_a(*right_arg_type) && - ASR::is_a(*right_type))) { + ASR::is_a(*right_type))) { found = true; Vec a_args; a_args.reserve(al, 2); @@ -1218,7 +1218,7 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, } bool is_op_overloaded(ASR::cmpopType op, std::string& intrinsic_op_name, - SymbolTable* curr_scope, ASR::StructType_t *left_struct) { + SymbolTable* curr_scope, ASR::Struct_t *left_struct) { bool result = true; switch(op) { case ASR::cmpopType::Eq: { diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h index a03c5b9b80..61bcda0df5 100644 --- a/src/libasr/asr_utils.h +++ b/src/libasr/asr_utils.h @@ -441,8 +441,8 @@ static inline char *symbol_name(const ASR::symbol_t *f) case ASR::symbolType::GenericProcedure: { return ASR::down_cast(f)->m_name; } - case ASR::symbolType::StructType: { - return ASR::down_cast(f)->m_name; + case ASR::symbolType::Struct: { + return ASR::down_cast(f)->m_name; } case ASR::symbolType::EnumType: { return ASR::down_cast(f)->m_name; @@ -554,8 +554,8 @@ static inline std::string type_to_str(const ASR::ttype_t *t) case ASR::ttypeType::List: { return "list"; } - case ASR::ttypeType::Struct: { - return ASRUtils::symbol_name(ASR::down_cast(t)->m_derived_type); + case ASR::ttypeType::StructType: { + return ASRUtils::symbol_name(ASR::down_cast(t)->m_derived_type); } case ASR::ttypeType::Class: { return ASRUtils::symbol_name(ASR::down_cast(t)->m_class_type); @@ -705,8 +705,8 @@ static inline std::pair symbol_dependencies(const ASR::symbol_t ASR::Function_t* sym = ASR::down_cast(f); return std::make_pair(sym->m_dependencies, sym->n_dependencies); } - case ASR::symbolType::StructType: { - ASR::StructType_t* sym = ASR::down_cast(f); + case ASR::symbolType::Struct: { + ASR::Struct_t* sym = ASR::down_cast(f); return std::make_pair(sym->m_dependencies, sym->n_dependencies); } case ASR::symbolType::EnumType: { @@ -747,8 +747,8 @@ static inline SymbolTable *symbol_parent_symtab(const ASR::symbol_t *f) case ASR::symbolType::GenericProcedure: { return ASR::down_cast(f)->m_parent_symtab; } - case ASR::symbolType::StructType: { - return ASR::down_cast(f)->m_symtab->parent; + case ASR::symbolType::Struct: { + return ASR::down_cast(f)->m_symtab->parent; } case ASR::symbolType::EnumType: { return ASR::down_cast(f)->m_symtab->parent; @@ -801,8 +801,8 @@ static inline SymbolTable *symbol_symtab(const ASR::symbol_t *f) return nullptr; //throw LCompilersException("GenericProcedure does not have a symtab"); } - case ASR::symbolType::StructType: { - return ASR::down_cast(f)->m_symtab; + case ASR::symbolType::Struct: { + return ASR::down_cast(f)->m_symtab; } case ASR::symbolType::EnumType: { return ASR::down_cast(f)->m_symtab; @@ -903,7 +903,7 @@ static inline bool is_c_ptr(ASR::symbol_t* v, std::string v_name="") { v_name = ASRUtils::symbol_name(v); } ASR::symbol_t* v_orig = ASRUtils::symbol_get_past_external(v); - if( ASR::is_a(*v_orig) ) { + if( ASR::is_a(*v_orig) ) { ASR::Module_t* der_type_module = ASRUtils::get_sym_module0(v_orig); return (der_type_module && std::string(der_type_module->m_name) == "lfortran_intrinsic_iso_c_binding" && @@ -1068,9 +1068,9 @@ static inline bool is_value_constant(ASR::expr_t *a_value) { ASR::ArrayPhysicalCast_t* array_physical_t = ASR::down_cast(a_value); return is_value_constant(array_physical_t->m_arg); - } case ASR::exprType::StructTypeConstructor: { - ASR::StructTypeConstructor_t* struct_type_constructor = - ASR::down_cast(a_value); + } case ASR::exprType::StructConstructor: { + ASR::StructConstructor_t* struct_type_constructor = + ASR::down_cast(a_value); bool is_constant = true; for( size_t i = 0; i < struct_type_constructor->n_args; i++ ) { if( struct_type_constructor->m_args[i].m_value ) { @@ -1481,8 +1481,8 @@ static inline std::string get_type_code(const ASR::ttype_t *t, bool use_undersco case ASR::ttypeType::CPtr: { return "CPtr"; } - case ASR::ttypeType::Struct: { - ASR::Struct_t* d = ASR::down_cast(t); + case ASR::ttypeType::StructType: { + ASR::StructType_t* d = ASR::down_cast(t); if( ASRUtils::symbol_get_past_external(d->m_derived_type) ) { res = symbol_name(ASRUtils::symbol_get_past_external(d->m_derived_type)); } else { @@ -1635,8 +1635,8 @@ static inline std::string type_to_str_python(const ASR::ttype_t *t, case ASR::ttypeType::CPtr: { return "CPtr"; } - case ASR::ttypeType::Struct: { - ASR::Struct_t* d = ASR::down_cast(t); + case ASR::ttypeType::StructType: { + ASR::StructType_t* d = ASR::down_cast(t); return "struct " + std::string(symbol_name(d->m_derived_type)); } case ASR::ttypeType::Enum: { @@ -1936,7 +1936,7 @@ bool use_overloaded_unary_minus(ASR::expr_t* operand, const std::function err); bool is_op_overloaded(ASR::binopType op, std::string& intrinsic_op_name, - SymbolTable* curr_scope, ASR::StructType_t* left_struct=nullptr); + SymbolTable* curr_scope, ASR::Struct_t* left_struct=nullptr); bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, ASR::cmpopType op, std::string& intrinsic_op_name, @@ -1947,7 +1947,7 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right, const std::function err); bool is_op_overloaded(ASR::cmpopType op, std::string& intrinsic_op_name, - SymbolTable* curr_scope, ASR::StructType_t *left_struct); + SymbolTable* curr_scope, ASR::Struct_t *left_struct); bool use_overloaded_assignment(ASR::expr_t* target, ASR::expr_t* value, SymbolTable* curr_scope, ASR::asr_t*& asr, @@ -2149,7 +2149,7 @@ inline size_t extract_dimensions_from_ttype(ASR::ttype_t *x, case ASR::ttypeType::Complex: case ASR::ttypeType::Character: case ASR::ttypeType::Logical: - case ASR::ttypeType::Struct: + case ASR::ttypeType::StructType: case ASR::ttypeType::Enum: case ASR::ttypeType::Union: case ASR::ttypeType::Class: @@ -2420,7 +2420,7 @@ inline bool ttype_set_dimensions(ASR::ttype_t** x, case ASR::ttypeType::Complex: case ASR::ttypeType::Character: case ASR::ttypeType::Logical: - case ASR::ttypeType::Struct: + case ASR::ttypeType::StructType: case ASR::ttypeType::Enum: case ASR::ttypeType::Union: case ASR::ttypeType::TypeParameter: { @@ -2504,9 +2504,9 @@ static inline ASR::ttype_t* duplicate_type(Allocator& al, const ASR::ttype_t* t, tnew->m_kind, tnew->m_len, tnew->m_len_expr)); break; } - case ASR::ttypeType::Struct: { - ASR::Struct_t* tnew = ASR::down_cast(t); - t_ = ASRUtils::TYPE(ASR::make_Struct_t(al, t->base.loc, tnew->m_derived_type)); + case ASR::ttypeType::StructType: { + ASR::StructType_t* tnew = ASR::down_cast(t); + t_ = ASRUtils::TYPE(ASR::make_StructType_t(al, t->base.loc, tnew->m_derived_type)); break; } case ASR::ttypeType::Class: { @@ -2654,9 +2654,9 @@ static inline ASR::ttype_t* duplicate_type_without_dims(Allocator& al, const ASR return ASRUtils::TYPE(ASR::make_Character_t(al, loc, tnew->m_kind, tnew->m_len, tnew->m_len_expr)); } - case ASR::ttypeType::Struct: { - ASR::Struct_t* tstruct = ASR::down_cast(t); - return ASRUtils::TYPE(ASR::make_Struct_t(al, loc, tstruct->m_derived_type)); + case ASR::ttypeType::StructType: { + ASR::StructType_t* tstruct = ASR::down_cast(t); + return ASRUtils::TYPE(ASR::make_StructType_t(al, loc, tstruct->m_derived_type)); } case ASR::ttypeType::Pointer: { ASR::Pointer_t* ptr = ASR::down_cast(t); @@ -2698,8 +2698,8 @@ inline bool is_same_type_pointer(ASR::ttype_t* source, ASR::ttype_t* dest) { dest = temp; } dest = ASRUtils::type_get_past_array(ASR::down_cast(dest)->m_type); - if( (ASR::is_a(*source) || ASR::is_a(*source)) && - (ASR::is_a(*dest) || ASR::is_a(*dest)) ) { + if( (ASR::is_a(*source) || ASR::is_a(*source)) && + (ASR::is_a(*dest) || ASR::is_a(*dest)) ) { return true; } bool res = source->type == dest->type; @@ -2872,20 +2872,20 @@ inline bool is_parent(SymbolTable* a, SymbolTable* b) { return false; } -inline bool is_parent(ASR::StructType_t* a, ASR::StructType_t* b) { +inline bool is_parent(ASR::Struct_t* a, ASR::Struct_t* b) { ASR::symbol_t* current_parent = b->m_parent; while( current_parent ) { current_parent = ASRUtils::symbol_get_past_external(current_parent); if( current_parent == (ASR::symbol_t*) a ) { return true; } - LCOMPILERS_ASSERT(ASR::is_a(*current_parent)); - current_parent = ASR::down_cast(current_parent)->m_parent; + LCOMPILERS_ASSERT(ASR::is_a(*current_parent)); + current_parent = ASR::down_cast(current_parent)->m_parent; } return false; } -inline bool is_derived_type_similar(ASR::StructType_t* a, ASR::StructType_t* b) { +inline bool is_derived_type_similar(ASR::Struct_t* a, ASR::Struct_t* b) { return a == b || is_parent(a, b) || is_parent(b, a) || (std::string(a->m_name) == "~abstract_type" && std::string(b->m_name) == "~abstract_type"); @@ -3080,13 +3080,13 @@ inline bool types_equal(ASR::ttype_t *a, ASR::ttype_t *b, ASR::List_t *b2 = ASR::down_cast(b); return types_equal(a2->m_type, b2->m_type); } - case (ASR::ttypeType::Struct) : { - ASR::Struct_t *a2 = ASR::down_cast(a); - ASR::Struct_t *b2 = ASR::down_cast(b); - ASR::StructType_t *a2_type = ASR::down_cast( + case (ASR::ttypeType::StructType) : { + ASR::StructType_t *a2 = ASR::down_cast(a); + ASR::StructType_t *b2 = ASR::down_cast(b); + ASR::Struct_t *a2_type = ASR::down_cast( ASRUtils::symbol_get_past_external( a2->m_derived_type)); - ASR::StructType_t *b2_type = ASR::down_cast( + ASR::Struct_t *b2_type = ASR::down_cast( ASRUtils::symbol_get_past_external( b2->m_derived_type)); return a2_type == b2_type; @@ -3103,9 +3103,9 @@ inline bool types_equal(ASR::ttype_t *a, ASR::ttype_t *b, ASR::ClassType_t *a2_type = ASR::down_cast(a2_typesym); ASR::ClassType_t *b2_type = ASR::down_cast(b2_typesym); return a2_type == b2_type; - } else if( a2_typesym->type == ASR::symbolType::StructType ) { - ASR::StructType_t *a2_type = ASR::down_cast(a2_typesym); - ASR::StructType_t *b2_type = ASR::down_cast(b2_typesym); + } else if( a2_typesym->type == ASR::symbolType::Struct ) { + ASR::Struct_t *a2_type = ASR::down_cast(a2_typesym); + ASR::Struct_t *b2_type = ASR::down_cast(b2_typesym); return is_derived_type_similar(a2_type, b2_type); } return false; @@ -3141,9 +3141,9 @@ inline bool types_equal(ASR::ttype_t *a, ASR::ttype_t *b, } default : return false; } - } else if( a->type == ASR::ttypeType::Struct && + } else if( a->type == ASR::ttypeType::StructType && b->type == ASR::ttypeType::Class ) { - ASR::Struct_t *a2 = ASR::down_cast(a); + ASR::StructType_t *a2 = ASR::down_cast(a); ASR::Class_t *b2 = ASR::down_cast(b); ASR::symbol_t* a2_typesym = ASRUtils::symbol_get_past_external(a2->m_derived_type); ASR::symbol_t* b2_typesym = ASRUtils::symbol_get_past_external(b2->m_class_type); @@ -3154,15 +3154,15 @@ inline bool types_equal(ASR::ttype_t *a, ASR::ttype_t *b, ASR::ClassType_t *a2_type = ASR::down_cast(a2_typesym); ASR::ClassType_t *b2_type = ASR::down_cast(b2_typesym); return a2_type == b2_type; - } else if( a2_typesym->type == ASR::symbolType::StructType ) { - ASR::StructType_t *a2_type = ASR::down_cast(a2_typesym); - ASR::StructType_t *b2_type = ASR::down_cast(b2_typesym); + } else if( a2_typesym->type == ASR::symbolType::Struct ) { + ASR::Struct_t *a2_type = ASR::down_cast(a2_typesym); + ASR::Struct_t *b2_type = ASR::down_cast(b2_typesym); return is_derived_type_similar(a2_type, b2_type); } } else if( a->type == ASR::ttypeType::Class && - b->type == ASR::ttypeType::Struct ) { + b->type == ASR::ttypeType::StructType ) { ASR::Class_t *a2 = ASR::down_cast(a); - ASR::Struct_t *b2 = ASR::down_cast(b); + ASR::StructType_t *b2 = ASR::down_cast(b); ASR::symbol_t* a2_typesym = ASRUtils::symbol_get_past_external(a2->m_class_type); ASR::symbol_t* b2_typesym = ASRUtils::symbol_get_past_external(b2->m_derived_type); if( a2_typesym->type != b2_typesym->type ) { @@ -3172,9 +3172,9 @@ inline bool types_equal(ASR::ttype_t *a, ASR::ttype_t *b, ASR::ClassType_t *a2_type = ASR::down_cast(a2_typesym); ASR::ClassType_t *b2_type = ASR::down_cast(b2_typesym); return a2_type == b2_type; - } else if( a2_typesym->type == ASR::symbolType::StructType ) { - ASR::StructType_t *a2_type = ASR::down_cast(a2_typesym); - ASR::StructType_t *b2_type = ASR::down_cast(b2_typesym); + } else if( a2_typesym->type == ASR::symbolType::Struct ) { + ASR::Struct_t *a2_type = ASR::down_cast(a2_typesym); + ASR::Struct_t *b2_type = ASR::down_cast(b2_typesym); return is_derived_type_similar(a2_type, b2_type); } } @@ -3263,13 +3263,13 @@ inline bool types_equal_with_substitution(ASR::ttype_t *a, ASR::ttype_t *b, ASR::List_t *b2 = ASR::down_cast(b); return types_equal_with_substitution(a2->m_type, b2->m_type, subs); } - case (ASR::ttypeType::Struct) : { - ASR::Struct_t *a2 = ASR::down_cast(a); - ASR::Struct_t *b2 = ASR::down_cast(b); - ASR::StructType_t *a2_type = ASR::down_cast( + case (ASR::ttypeType::StructType) : { + ASR::StructType_t *a2 = ASR::down_cast(a); + ASR::StructType_t *b2 = ASR::down_cast(b); + ASR::Struct_t *a2_type = ASR::down_cast( ASRUtils::symbol_get_past_external( a2->m_derived_type)); - ASR::StructType_t *b2_type = ASR::down_cast( + ASR::Struct_t *b2_type = ASR::down_cast( ASRUtils::symbol_get_past_external( b2->m_derived_type)); return a2_type == b2_type; @@ -3286,9 +3286,9 @@ inline bool types_equal_with_substitution(ASR::ttype_t *a, ASR::ttype_t *b, ASR::ClassType_t *a2_type = ASR::down_cast(a2_typesym); ASR::ClassType_t *b2_type = ASR::down_cast(b2_typesym); return a2_type == b2_type; - } else if( a2_typesym->type == ASR::symbolType::StructType ) { - ASR::StructType_t *a2_type = ASR::down_cast(a2_typesym); - ASR::StructType_t *b2_type = ASR::down_cast(b2_typesym); + } else if( a2_typesym->type == ASR::symbolType::Struct ) { + ASR::Struct_t *a2_type = ASR::down_cast(a2_typesym); + ASR::Struct_t *b2_type = ASR::down_cast(b2_typesym); return is_derived_type_similar(a2_type, b2_type); } return false; @@ -3324,9 +3324,9 @@ inline bool types_equal_with_substitution(ASR::ttype_t *a, ASR::ttype_t *b, } default : return false; } - } else if( a->type == ASR::ttypeType::Struct && + } else if( a->type == ASR::ttypeType::StructType && b->type == ASR::ttypeType::Class ) { - ASR::Struct_t *a2 = ASR::down_cast(a); + ASR::StructType_t *a2 = ASR::down_cast(a); ASR::Class_t *b2 = ASR::down_cast(b); ASR::symbol_t* a2_typesym = ASRUtils::symbol_get_past_external(a2->m_derived_type); ASR::symbol_t* b2_typesym = ASRUtils::symbol_get_past_external(b2->m_class_type); @@ -3337,15 +3337,15 @@ inline bool types_equal_with_substitution(ASR::ttype_t *a, ASR::ttype_t *b, ASR::ClassType_t *a2_type = ASR::down_cast(a2_typesym); ASR::ClassType_t *b2_type = ASR::down_cast(b2_typesym); return a2_type == b2_type; - } else if( a2_typesym->type == ASR::symbolType::StructType ) { - ASR::StructType_t *a2_type = ASR::down_cast(a2_typesym); - ASR::StructType_t *b2_type = ASR::down_cast(b2_typesym); + } else if( a2_typesym->type == ASR::symbolType::Struct ) { + ASR::Struct_t *a2_type = ASR::down_cast(a2_typesym); + ASR::Struct_t *b2_type = ASR::down_cast(b2_typesym); return is_derived_type_similar(a2_type, b2_type); } } else if( a->type == ASR::ttypeType::Class && - b->type == ASR::ttypeType::Struct ) { + b->type == ASR::ttypeType::StructType ) { ASR::Class_t *a2 = ASR::down_cast(a); - ASR::Struct_t *b2 = ASR::down_cast(b); + ASR::StructType_t *b2 = ASR::down_cast(b); ASR::symbol_t* a2_typesym = ASRUtils::symbol_get_past_external(a2->m_class_type); ASR::symbol_t* b2_typesym = ASRUtils::symbol_get_past_external(b2->m_derived_type); if( a2_typesym->type != b2_typesym->type ) { @@ -3355,9 +3355,9 @@ inline bool types_equal_with_substitution(ASR::ttype_t *a, ASR::ttype_t *b, ASR::ClassType_t *a2_type = ASR::down_cast(a2_typesym); ASR::ClassType_t *b2_type = ASR::down_cast(b2_typesym); return a2_type == b2_type; - } else if( a2_typesym->type == ASR::symbolType::StructType ) { - ASR::StructType_t *a2_type = ASR::down_cast(a2_typesym); - ASR::StructType_t *b2_type = ASR::down_cast(b2_typesym); + } else if( a2_typesym->type == ASR::symbolType::Struct ) { + ASR::Struct_t *a2_type = ASR::down_cast(a2_typesym); + ASR::Struct_t *b2_type = ASR::down_cast(b2_typesym); return is_derived_type_similar(a2_type, b2_type); } } @@ -3607,8 +3607,8 @@ static inline ASR::symbol_t* import_struct_instance_member(Allocator& al, ASR::s mem_type = ASRUtils::type_get_past_array( ASRUtils::type_get_past_pointer( ASRUtils::type_get_past_allocatable(mem_type))); - if( mem_type && ASR::is_a(*mem_type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(mem_type); + if( mem_type && ASR::is_a(*mem_type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(mem_type); std::string struct_type_name = ASRUtils::symbol_name(struct_t->m_derived_type); ASR::symbol_t* struct_t_m_derived_type = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); if( scope->resolve_symbol(struct_type_name) == nullptr ) { @@ -3621,9 +3621,9 @@ static inline ASR::symbol_t* import_struct_instance_member(Allocator& al, ASR::s nullptr, 0, s2c(al, struct_type_name), ASR::accessType::Public)); scope->add_symbol(struct_type_name_, imported_struct_type); } - mem_type = ASRUtils::TYPE(ASR::make_Struct_t(al, mem_type->base.loc, scope->get_symbol(struct_type_name_))); + mem_type = ASRUtils::TYPE(ASR::make_StructType_t(al, mem_type->base.loc, scope->get_symbol(struct_type_name_))); } else { - mem_type = ASRUtils::TYPE(ASR::make_Struct_t(al, mem_type->base.loc, + mem_type = ASRUtils::TYPE(ASR::make_StructType_t(al, mem_type->base.loc, scope->resolve_symbol(struct_type_name))); } } @@ -3853,7 +3853,7 @@ class FixScopedTypeVisitor: public ASR::BaseExprReplacer { FixScopedTypeVisitor(Allocator& al_, SymbolTable* current_scope_) : al(al_), current_scope(current_scope_) {} - void replace_Struct(ASR::Struct_t* x) { + void replace_StructType(ASR::StructType_t* x) { ASR::symbol_t* m_derived_type = current_scope->resolve_symbol( ASRUtils::symbol_name(x->m_derived_type)); if (m_derived_type == nullptr) { @@ -3924,7 +3924,7 @@ class ReplaceWithFunctionParamVisitor: public ASR::BaseExprReplacerm_derived_type); ASR::symbol_t* derived_type_sym = current_scope->resolve_symbol(derived_type_name); LCOMPILERS_ASSERT_MSG( derived_type_sym != nullptr, @@ -4080,9 +4080,9 @@ class SymbolDuplicator { new_symbol_name = block->m_name; break; } - case ASR::symbolType::StructType: { - ASR::StructType_t* struct_type = ASR::down_cast(symbol); - new_symbol = duplicate_StructType(struct_type, destination_symtab); + case ASR::symbolType::Struct: { + ASR::Struct_t* struct_type = ASR::down_cast(symbol); + new_symbol = duplicate_Struct(struct_type, destination_symtab); new_symbol_name = struct_type->m_name; break; } @@ -4114,8 +4114,8 @@ class SymbolDuplicator { if( !node_duplicator.success ) { return nullptr; } - if (ASR::is_a(*m_type)) { - ASR::Struct_t* st = ASR::down_cast(m_type); + if (ASR::is_a(*m_type)) { + ASR::StructType_t* st = ASR::down_cast(m_type); std::string derived_type_name = ASRUtils::symbol_name(st->m_derived_type); ASR::symbol_t* derived_type_sym = destination_symtab->resolve_symbol(derived_type_name); LCOMPILERS_ASSERT_MSG( derived_type_sym != nullptr, "derived_type_sym cannot be nullptr"); @@ -4255,11 +4255,11 @@ class SymbolDuplicator { new_body.p, new_body.size())); } - ASR::symbol_t* duplicate_StructType(ASR::StructType_t* struct_type_t, + ASR::symbol_t* duplicate_Struct(ASR::Struct_t* struct_type_t, SymbolTable* destination_symtab) { SymbolTable* struct_type_symtab = al.make_new(destination_symtab); duplicate_SymbolTable(struct_type_t->m_symtab, struct_type_symtab); - return ASR::down_cast(ASR::make_StructType_t( + return ASR::down_cast(ASR::make_Struct_t( al, struct_type_t->base.base.loc, struct_type_symtab, struct_type_t->m_name, struct_type_t->m_dependencies, struct_type_t->n_dependencies, struct_type_t->m_members, struct_type_t->n_members, struct_type_t->m_abi, @@ -4515,7 +4515,7 @@ static inline bool is_pass_array_by_data_possible(ASR::Function_t* x, std::vecto argi->m_intent == ASRUtils::intent_out || argi->m_intent == ASRUtils::intent_inout) && !ASR::is_a(*argi->m_type) && - !ASR::is_a(*argi->m_type) && + !ASR::is_a(*argi->m_type) && !ASR::is_a(*argi->m_type) && argi->m_presence != ASR::presenceType::Optional) { v.push_back(i); @@ -4868,8 +4868,8 @@ static inline void import_struct_t(Allocator& al, } ASR::ttype_t* var_type_unwrapped = ASRUtils::type_get_past_allocatable( ASRUtils::type_get_past_pointer(ASRUtils::type_get_past_array(var_type))); - if( ASR::is_a(*var_type_unwrapped) ) { - ASR::symbol_t* der_sym = ASR::down_cast(var_type_unwrapped)->m_derived_type; + if( ASR::is_a(*var_type_unwrapped) ) { + ASR::symbol_t* der_sym = ASR::down_cast(var_type_unwrapped)->m_derived_type; if( (ASR::asr_t*) ASRUtils::get_asr_owner(der_sym) != current_scope->asr_owner ) { std::string sym_name = ASRUtils::symbol_name(ASRUtils::symbol_get_past_external(der_sym)); if( current_scope->resolve_symbol(sym_name) == nullptr ) { @@ -4882,7 +4882,7 @@ static inline void import_struct_t(Allocator& al, } else { der_sym = current_scope->resolve_symbol(sym_name); } - var_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, der_sym)); + var_type = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, der_sym)); if( is_array ) { var_type = ASRUtils::make_Array_t_util(al, loc, var_type, m_dims, n_dims, ASR::abiType::Source, false, ptype, true); diff --git a/src/libasr/asr_verify.cpp b/src/libasr/asr_verify.cpp index 19adc83ae8..37248c3883 100644 --- a/src/libasr/asr_verify.cpp +++ b/src/libasr/asr_verify.cpp @@ -509,15 +509,15 @@ class VerifyVisitor : public BaseWalkVisitor SymbolTable *parent_symtab = current_symtab; current_symtab = x.m_symtab; require(x.m_name != nullptr, - "The StructType::m_name cannot be nullptr"); + "The Struct::m_name cannot be nullptr"); require(x.m_symtab != nullptr, - "The StructType::m_symtab cannot be nullptr"); + "The Struct::m_symtab cannot be nullptr"); require(x.m_symtab->parent == parent_symtab, - "The StructType::m_symtab->parent is not the right parent"); + "The Struct::m_symtab->parent is not the right parent"); require(x.m_symtab->asr_owner == (ASR::asr_t*)&x, "The X::m_symtab::asr_owner must point to X"); require(id_symtab_map.find(x.m_symtab->counter) == id_symtab_map.end(), - "StructType::m_symtab->counter must be unique"); + "Struct::m_symtab->counter must be unique"); require(ASRUtils::symbol_symtab(down_cast(current_symtab->asr_owner)) == current_symtab, "The asr_owner invariant failed"); id_symtab_map[x.m_symtab->counter] = x.m_symtab; @@ -526,7 +526,7 @@ class VerifyVisitor : public BaseWalkVisitor this->visit_symbol(*a.second); if( ASR::is_a(*a.second) || ASR::is_a(*a.second) || - ASR::is_a(*a.second) || + ASR::is_a(*a.second) || ASR::is_a(*a.second) || ASR::is_a(*a.second) || ASR::is_a(*a.second) ) { @@ -537,8 +537,8 @@ class VerifyVisitor : public BaseWalkVisitor ASR::ttype_t* var_type = ASRUtils::type_get_past_pointer(ASRUtils::symbol_type(a.second)); char* aggregate_type_name = nullptr; ASR::symbol_t* sym = nullptr; - if( ASR::is_a(*var_type) ) { - sym = ASR::down_cast(var_type)->m_derived_type; + if( ASR::is_a(*var_type) ) { + sym = ASR::down_cast(var_type)->m_derived_type; aggregate_type_name = ASRUtils::symbol_name(sym); } else if( ASR::is_a(*var_type) ) { sym = ASR::down_cast(var_type)->m_enum_type; @@ -569,7 +569,7 @@ class VerifyVisitor : public BaseWalkVisitor current_symtab = parent_symtab; } - void visit_StructType(const StructType_t& x) { + void visit_Struct(const Struct_t& x) { visit_UserDefinedType(x); if( !x.m_alignment ) { return ; @@ -663,7 +663,7 @@ class VerifyVisitor : public BaseWalkVisitor if (ASR::is_a(*asr_owner_sym)) { is_module = true; } - if (ASR::is_a(*asr_owner_sym)) { + if (ASR::is_a(*asr_owner_sym)) { is_struct = true; } } @@ -719,7 +719,7 @@ class VerifyVisitor : public BaseWalkVisitor require(std::string(x.m_original_name) == std::string(orig_name), "ExternalSymbol::m_original_name must match external->m_name"); ASR::Module_t *m = ASRUtils::get_sym_module(x.m_external); - ASR::StructType_t* sm = nullptr; + ASR::Struct_t* sm = nullptr; ASR::EnumType_t* em = nullptr; ASR::UnionType_t* um = nullptr; ASR::Function_t* fm = nullptr; @@ -728,12 +728,12 @@ class VerifyVisitor : public BaseWalkVisitor std::string asr_owner_name = ""; if( !is_valid_owner ) { ASR::symbol_t* asr_owner_sym = ASRUtils::get_asr_owner(x.m_external); - is_valid_owner = (ASR::is_a(*asr_owner_sym) || + is_valid_owner = (ASR::is_a(*asr_owner_sym) || ASR::is_a(*asr_owner_sym) || ASR::is_a(*asr_owner_sym) || ASR::is_a(*asr_owner_sym)); - if( ASR::is_a(*asr_owner_sym) ) { - sm = ASR::down_cast(asr_owner_sym); + if( ASR::is_a(*asr_owner_sym) ) { + sm = ASR::down_cast(asr_owner_sym); asr_owner_name = sm->m_name; } else if( ASR::is_a(*asr_owner_sym) ) { em = ASR::down_cast(asr_owner_sym); @@ -968,8 +968,8 @@ class VerifyVisitor : public BaseWalkVisitor ASR::ttype_t *t2 = ASRUtils::type_get_past_pointer(ASRUtils::expr_type(dt)); ASR::symbol_t *type_sym=nullptr; switch (t2->type) { - case (ASR::ttypeType::Struct): { - type_sym = ASR::down_cast(t2)->m_derived_type; + case (ASR::ttypeType::StructType): { + type_sym = ASR::down_cast(t2)->m_derived_type; break; } case (ASR::ttypeType::Class): { @@ -978,7 +978,7 @@ class VerifyVisitor : public BaseWalkVisitor } default : require_with_loc(false, - "m_dt::m_v::m_type must point to a type with a symbol table (Struct or Class)", + "m_dt::m_v::m_type must point to a type with a symbol table (StructType or Class)", dt->base.loc); } return get_dt_symtab(type_sym); @@ -987,15 +987,15 @@ class VerifyVisitor : public BaseWalkVisitor ASR::symbol_t *get_parent_type_dt(ASR::symbol_t *dt) { ASR::symbol_t *parent = nullptr; switch (dt->type) { - case (ASR::symbolType::StructType): { + case (ASR::symbolType::Struct): { dt = ASRUtils::symbol_get_past_external(dt); - ASR::StructType_t* der_type = ASR::down_cast(dt); + ASR::Struct_t* der_type = ASR::down_cast(dt); parent = der_type->m_parent; break; } default : require_with_loc(false, - "m_dt::m_v::m_type must point to a Struct type", + "m_dt::m_v::m_type must point to a StructType type", dt->base.loc); } return parent; @@ -1006,25 +1006,25 @@ class VerifyVisitor : public BaseWalkVisitor ASR::symbol_t *type_sym=nullptr; ASR::symbol_t *parent = nullptr; switch (t2->type) { - case (ASR::ttypeType::Struct): { - type_sym = ASR::down_cast(t2)->m_derived_type; + case (ASR::ttypeType::StructType): { + type_sym = ASR::down_cast(t2)->m_derived_type; type_sym = ASRUtils::symbol_get_past_external(type_sym); - ASR::StructType_t* der_type = ASR::down_cast(type_sym); + ASR::Struct_t* der_type = ASR::down_cast(type_sym); parent = der_type->m_parent; break; } case (ASR::ttypeType::Class): { type_sym = ASR::down_cast(t2)->m_class_type; type_sym = ASRUtils::symbol_get_past_external(type_sym); - if( type_sym->type == ASR::symbolType::StructType ) { - ASR::StructType_t* der_type = ASR::down_cast(type_sym); + if( type_sym->type == ASR::symbolType::Struct ) { + ASR::Struct_t* der_type = ASR::down_cast(type_sym); parent = der_type->m_parent; } break; } default : require_with_loc(false, - "m_dt::m_v::m_type must point to a Struct type", + "m_dt::m_v::m_type must point to a StructType type", dt->base.loc); } return parent; @@ -1133,13 +1133,13 @@ class VerifyVisitor : public BaseWalkVisitor visit_ttype(*x.m_type); } - void visit_Struct(const Struct_t &x) { + void visit_StructType(const StructType_t &x) { std::string symbol_owner = "global scope"; if( ASRUtils::get_asr_owner(x.m_derived_type) ) { symbol_owner = ASRUtils::symbol_name(ASRUtils::get_asr_owner(x.m_derived_type)); } require(symtab_in_scope(current_symtab, x.m_derived_type), - "Struct::m_derived_type '" + + "StructType::m_derived_type '" + std::string(ASRUtils::symbol_name(x.m_derived_type)) + "' cannot point outside of its symbol table, owner: " + symbol_owner); diff --git a/src/libasr/codegen/asr_to_c.cpp b/src/libasr/codegen/asr_to_c.cpp index 62b08d8203..381e3c7902 100644 --- a/src/libasr/codegen/asr_to_c.cpp +++ b/src/libasr/codegen/asr_to_c.cpp @@ -149,12 +149,12 @@ class ASRToCVisitor : public BaseCCPPVisitor } } - void allocate_array_members_of_struct(ASR::StructType_t* der_type_t, std::string& sub, + void allocate_array_members_of_struct(ASR::Struct_t* der_type_t, std::string& sub, std::string indent, std::string name) { for( auto itr: der_type_t->m_symtab->get_scope() ) { ASR::symbol_t *sym = ASRUtils::symbol_get_past_external(itr.second); if( ASR::is_a(*sym) || - ASR::is_a(*sym) ) { + ASR::is_a(*sym) ) { continue ; } ASR::ttype_t* mem_type = ASRUtils::symbol_type(sym); @@ -178,9 +178,9 @@ class ASRToCVisitor : public BaseCCPPVisitor if( !ASRUtils::is_fixed_size_array(m_dims, n_dims) ) { sub += indent + name + "->" + itr.first + " = " + mem_var_name + ";\n"; } - } else if( ASR::is_a(*mem_type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(mem_type); - ASR::StructType_t* struct_type_t = ASR::down_cast( + } else if( ASR::is_a(*mem_type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(mem_type); + ASR::Struct_t* struct_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); allocate_array_members_of_struct(struct_type_t, sub, indent, "(&(" + name + "->" + itr.first + "))"); } @@ -196,7 +196,7 @@ class ASRToCVisitor : public BaseCCPPVisitor if( is_array ) { bool is_fixed_size = true; dims = convert_dims_c(n_dims, m_dims, v_m_type, is_fixed_size, true); - bool is_struct_type_member = ASR::is_a( + bool is_struct_type_member = ASR::is_a( *ASR::down_cast(v.m_parent_symtab->asr_owner)); if( is_fixed_size && is_struct_type_member ) { if( !force_declare ) { @@ -360,8 +360,8 @@ class ASRToCVisitor : public BaseCCPPVisitor std::string dims = convert_dims_c(n_dims, m_dims, v_m_type, is_fixed_size); sub = format_type_c(dims, type_name, v.m_name, use_ref, dummy); } - } else if(ASR::is_a(*t2)) { - ASR::Struct_t *t = ASR::down_cast(t2); + } else if(ASR::is_a(*t2)) { + ASR::StructType_t *t = ASR::down_cast(t2); std::string der_type_name = ASRUtils::symbol_name(t->m_derived_type); if( is_array ) { bool is_fixed_size = true; @@ -425,15 +425,15 @@ class ASRToCVisitor : public BaseCCPPVisitor sub = format_type_c(dims, "char *", v.m_name, use_ref, dummy); if(v.m_intent == ASRUtils::intent_local && !(ASR::is_a(*v.m_parent_symtab->asr_owner) && - ASR::is_a( + ASR::is_a( *ASR::down_cast(v.m_parent_symtab->asr_owner))) && !(dims.size() == 0 && v.m_symbolic_value) && !do_not_initialize) { sub += " = NULL"; return sub; } - } else if (ASR::is_a(*v_m_type)) { + } else if (ASR::is_a(*v_m_type)) { std::string indent(indentation_level*indentation_spaces, ' '); - ASR::Struct_t *t = ASR::down_cast(v_m_type); + ASR::StructType_t *t = ASR::down_cast(v_m_type); std::string der_type_name = ASRUtils::symbol_name(t->m_derived_type); if( is_array ) { bool is_fixed_size = true; @@ -469,7 +469,7 @@ class ASRToCVisitor : public BaseCCPPVisitor sub += " = " + value_var_name; } else { sub += " = &" + value_var_name + ";\n"; - ASR::StructType_t* der_type_t = ASR::down_cast( + ASR::Struct_t* der_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(t->m_derived_type)); allocate_array_members_of_struct(der_type_t, sub, indent, std::string(v.m_name)); sub.pop_back(); @@ -631,7 +631,7 @@ R"( std::map> struct_dep_graph; for (auto &item : x.m_symtab->get_scope()) { - if (ASR::is_a(*item.second) || + if (ASR::is_a(*item.second) || ASR::is_a(*item.second) || ASR::is_a(*item.second)) { std::vector struct_deps_vec; @@ -753,7 +753,7 @@ R"( } std::map> struct_dep_graph; for (auto &item : x.m_symtab->get_scope()) { - if (ASR::is_a(*item.second) || + if (ASR::is_a(*item.second) || ASR::is_a(*item.second) || ASR::is_a(*item.second)) { std::vector struct_deps_vec; @@ -878,10 +878,10 @@ R"( // Initialise Numpy if( ASR::is_a(*itr.second) ) { visit_AggregateTypeUtil(*ASR::down_cast(itr.second), "union", src_dest); - } else if( ASR::is_a(*itr.second) ) { - std::string struct_c_type_name = get_StructCTypeName( - *ASR::down_cast(itr.second)); - visit_AggregateTypeUtil(*ASR::down_cast(itr.second), + } else if( ASR::is_a(*itr.second) ) { + std::string struct_c_type_name = get_StructTypeCTypeName( + *ASR::down_cast(itr.second)); + visit_AggregateTypeUtil(*ASR::down_cast(itr.second), struct_c_type_name, src_dest); } } @@ -907,7 +907,7 @@ R"( // Initialise Numpy src_dest += open_struct + body + end_struct; } - std::string get_StructCTypeName(const ASR::StructType_t& x) { + std::string get_StructTypeCTypeName(const ASR::Struct_t& x) { std::string c_type_name = "struct"; if( x.m_is_packed ) { std::string attr_args = "(packed"; @@ -926,9 +926,9 @@ R"( // Initialise Numpy return c_type_name; } - void visit_StructType(const ASR::StructType_t& x) { + void visit_Struct(const ASR::Struct_t& x) { src = ""; - std::string c_type_name = get_StructCTypeName(x); + std::string c_type_name = get_StructTypeCTypeName(x); visit_AggregateTypeUtil(x, c_type_name, array_types_decls); src = ""; } @@ -1320,7 +1320,7 @@ R"( // Initialise Numpy ASR::dimension_t* m_dims; int n_dims = ASRUtils::extract_dimensions_from_ttype(x_mv_type, m_dims); bool is_data_only_array = ASRUtils::is_fixed_size_array(m_dims, n_dims) && - ASR::is_a(*ASRUtils::get_asr_owner(x.m_v)); + ASR::is_a(*ASRUtils::get_asr_owner(x.m_v)); if( is_data_only_array || ASRUtils::is_simd_array(x.m_v)) { std::string index = ""; std::string out = array; diff --git a/src/libasr/codegen/asr_to_c_cpp.h b/src/libasr/codegen/asr_to_c_cpp.h index 9b980767ad..c0404b70f9 100644 --- a/src/libasr/codegen/asr_to_c_cpp.h +++ b/src/libasr/codegen/asr_to_c_cpp.h @@ -87,11 +87,11 @@ struct CPPDeclarationOptions: public DeclarationOptions { } }; -template -class BaseCCPPVisitor : public ASR::BaseVisitor +template +class BaseCCPPVisitor : public ASR::BaseVisitor { private: - Struct& self() { return static_cast(*this); } + StructType& self() { return static_cast(*this); } public: diag::Diagnostics &diag; Platform platform; @@ -1094,13 +1094,13 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) { } else if (ASR::is_a(*m_args[i].m_value)) { ASR::Variable_t* param = ASRUtils::EXPR2VAR(f->m_args[i]); if (param->m_intent == ASRUtils::intent_inout - || param->m_intent == ASRUtils::intent_out || ASR::is_a(*type)) { + || param->m_intent == ASRUtils::intent_out || ASR::is_a(*type)) { args += "&" + src; } else { args += src; } } else { - if( ASR::is_a(*type) ) { + if( ASR::is_a(*type) ) { args += "&" + src; } else { args += src; @@ -1354,14 +1354,14 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) { self().visit_expr(*x.m_value); std::string value = src; ASR::ttype_t* value_type = ASRUtils::expr_type(x.m_value); - if( ASR::is_a(*value_type) ) { + if( ASR::is_a(*value_type) ) { if (ASR::is_a(*x.m_value) || ASR::is_a(*x.m_value) || ASR::is_a(*x.m_value)) { value = "&" + value; } } - if( ASR::is_a(*m_target_type) ) { + if( ASR::is_a(*m_target_type) ) { if (ASR::is_a(*x.m_target) || ASR::is_a(*x.m_target) || ASR::is_a(*x.m_target)) { @@ -1411,9 +1411,9 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) { ASR::dimension_t* m_value_dims = nullptr; size_t n_value_dims = ASRUtils::extract_dimensions_from_ttype(m_value_type, m_value_dims); bool is_target_data_only_array = ASRUtils::is_fixed_size_array(m_target_dims, n_target_dims) && - ASR::is_a(*ASRUtils::get_asr_owner(x.m_target)); + ASR::is_a(*ASRUtils::get_asr_owner(x.m_target)); bool is_value_data_only_array = ASRUtils::is_fixed_size_array(m_value_dims, n_value_dims) && - ASRUtils::get_asr_owner(x.m_value) && ASR::is_a(*ASRUtils::get_asr_owner(x.m_value)); + ASRUtils::get_asr_owner(x.m_value) && ASR::is_a(*ASRUtils::get_asr_owner(x.m_value)); if( is_target_data_only_array || is_value_data_only_array ) { int64_t target_size = -1, value_size = -1; if( !is_target_data_only_array ) { @@ -2440,7 +2440,7 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) { std::string arg_src = std::move(src); std::string addr_prefix = "&"; if( ASRUtils::is_array(ASRUtils::expr_type(x.m_arg)) || - ASR::is_a(*ASRUtils::expr_type(x.m_arg)) ) { + ASR::is_a(*ASRUtils::expr_type(x.m_arg)) ) { addr_prefix.clear(); } src = addr_prefix + arg_src; @@ -2483,9 +2483,9 @@ PyMODINIT_FUNC PyInit_lpython_module_)" + fn_name + R"((void) { src = "CMPLX(" + re + "," + im + ")"; } - void visit_StructTypeConstructor(const ASR::StructTypeConstructor_t &x) { + void visit_StructConstructor(const ASR::StructConstructor_t &x) { std::string out = "{"; - ASR::StructType_t *st = ASR::down_cast(x.m_dt_sym); + ASR::Struct_t *st = ASR::down_cast(x.m_dt_sym); for (size_t i = 0; i < x.n_args; i++) { if (x.m_args[i].m_value) { out += "."; diff --git a/src/libasr/codegen/asr_to_cpp.cpp b/src/libasr/codegen/asr_to_cpp.cpp index 2a0e680712..4c50fed4bd 100644 --- a/src/libasr/codegen/asr_to_cpp.cpp +++ b/src/libasr/codegen/asr_to_cpp.cpp @@ -294,8 +294,8 @@ class ASRToCPPVisitor : public BaseCCPPVisitor extract_dimensions(v.m_type) dims = convert_dims(n_dims, m_dims, size); sub = format_type(dims, "std::string", v.m_name, use_ref, dummy); - } else if (ASR::is_a(*v.m_type)) { - ASR::Struct_t *t = ASR::down_cast(v_m_type); + } else if (ASR::is_a(*v.m_type)) { + ASR::StructType_t *t = ASR::down_cast(v_m_type); std::string der_type_name = ASRUtils::symbol_name(t->m_derived_type); std::string encoded_type_name = "x" + der_type_name; std::string type_name = std::string("struct ") + der_type_name; diff --git a/src/libasr/codegen/asr_to_fortran.cpp b/src/libasr/codegen/asr_to_fortran.cpp index a9964c7524..02cb20ad9b 100644 --- a/src/libasr/codegen/asr_to_fortran.cpp +++ b/src/libasr/codegen/asr_to_fortran.cpp @@ -227,8 +227,8 @@ class ASRToFortranVisitor : public ASR::BaseVisitor } case ASR::ttypeType::Pointer: { r = get_type(down_cast(t)->m_type) + ", pointer"; break; - } case ASR::ttypeType::Struct: { - ASR::Struct_t* struct_type = down_cast(t); + } case ASR::ttypeType::StructType: { + ASR::StructType_t* struct_type = down_cast(t); std::string struct_name = ASRUtils::symbol_name(struct_type->m_derived_type); r = "type("; r += struct_name; @@ -307,7 +307,7 @@ class ASRToFortranVisitor : public ASR::BaseVisitor r += "\n"; std::map> struct_dep_graph; for (auto &item : x.m_symtab->get_scope()) { - if (ASR::is_a(*item.second) || + if (ASR::is_a(*item.second) || ASR::is_a(*item.second) || ASR::is_a(*item.second)) { std::vector struct_deps_vec; @@ -388,7 +388,7 @@ class ASRToFortranVisitor : public ASR::BaseVisitor } std::map> struct_dep_graph; for (auto &item : x.m_symtab->get_scope()) { - if (ASR::is_a(*item.second) || + if (ASR::is_a(*item.second) || ASR::is_a(*item.second) || ASR::is_a(*item.second)) { std::vector struct_deps_vec; @@ -599,7 +599,7 @@ class ASRToFortranVisitor : public ASR::BaseVisitor void visit_ExternalSymbol(const ASR::ExternalSymbol_t &x) { ASR::symbol_t *sym = down_cast( ASRUtils::symbol_parent_symtab(x.m_external)->asr_owner); - if (!is_a(*sym)) { + if (!is_a(*sym)) { src = indent; src += "use "; src.append(x.m_module_name); @@ -609,7 +609,7 @@ class ASRToFortranVisitor : public ASR::BaseVisitor } } - void visit_StructType(const ASR::StructType_t &x) { + void visit_Struct(const ASR::Struct_t &x) { std::string r = indent; r += "type :: "; r.append(x.m_name); @@ -1326,7 +1326,7 @@ class ASRToFortranVisitor : public ASR::BaseVisitor // void visit_IntrinsicImpureFunction(const ASR::IntrinsicImpureFunction_t &x) {} - void visit_StructTypeConstructor(const ASR::StructTypeConstructor_t &x) { + void visit_StructConstructor(const ASR::StructConstructor_t &x) { std::string r = indent; r += ASRUtils::symbol_name(x.m_dt_sym); r += "("; diff --git a/src/libasr/codegen/asr_to_julia.cpp b/src/libasr/codegen/asr_to_julia.cpp index 5583990fe7..04dd706b09 100644 --- a/src/libasr/codegen/asr_to_julia.cpp +++ b/src/libasr/codegen/asr_to_julia.cpp @@ -388,9 +388,9 @@ class ASRToJuliaVisitor : public ASR::BaseVisitor } else { sub = format_type(type_name, v.m_name, use_ref, init_default ? "\"\"" : ""); } - } else if (ASR::is_a(*v_m_type)) { + } else if (ASR::is_a(*v_m_type)) { // TODO: handle this - ASR::Struct_t* t = ASR::down_cast(v_m_type); + ASR::StructType_t* t = ASR::down_cast(v_m_type); std::string der_type_name = ASRUtils::symbol_name(t->m_derived_type); if (is_array) { generate_array_decl(sub, @@ -978,8 +978,8 @@ class ASRToJuliaVisitor : public ASR::BaseVisitor std::string type_name = "String"; generate_array_decl( out, std::string(v->m_name), type_name, _dims, nullptr, n_dims, true, true); - } else if (ASR::is_a(*v->m_type)) { - ASR::Struct_t* t = ASR::down_cast(v->m_type); + } else if (ASR::is_a(*v->m_type)) { + ASR::StructType_t* t = ASR::down_cast(v->m_type); std::string der_type_name = ASRUtils::symbol_name(t->m_derived_type); generate_array_decl( out, std::string(v->m_name), der_type_name, _dims, nullptr, n_dims, true, true); diff --git a/src/libasr/codegen/asr_to_llvm.cpp b/src/libasr/codegen/asr_to_llvm.cpp index 61e54152aa..4921c46f75 100644 --- a/src/libasr/codegen/asr_to_llvm.cpp +++ b/src/libasr/codegen/asr_to_llvm.cpp @@ -981,7 +981,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor builder->CreateMemSet(LLVM::CreateLoad(*builder, x_arr), llvm::ConstantInt::get(llvm::Type::getInt8Ty(context), llvm::APInt(8, 0)), alloc_size, llvm::MaybeAlign()); - } else if(ASR::is_a(*curr_arg_m_a_type) || + } else if(ASR::is_a(*curr_arg_m_a_type) || ASR::is_a(*curr_arg_m_a_type) || ASR::is_a(*curr_arg_m_a_type)) { llvm::Value* malloc_size = SizeOfTypeUtil(curr_arg_m_a_type, llvm_utils->getIntType(4), @@ -999,7 +999,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor curr_arg_m_a_type, curr_arg_m_a_type->base.loc); llvm::Type* llvm_data_type = llvm_utils->get_type_from_ttype_t_util(asr_data_type, module.get()); fill_malloc_array_details(x_arr, llvm_data_type, curr_arg.m_dims, curr_arg.n_dims, realloc); - if( ASR::is_a(*ASRUtils::extract_type(ASRUtils::expr_type(tmp_expr)))) { + if( ASR::is_a(*ASRUtils::extract_type(ASRUtils::expr_type(tmp_expr)))) { allocate_array_members_of_struct_arrays(LLVM::CreateLoad(*builder, x_arr), ASRUtils::expr_type(tmp_expr)); } @@ -1135,9 +1135,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASRUtils::expr_type(sm->m_v)); llvm::Value* dt = tmp; ASR::symbol_t *struct_sym = nullptr; - if (ASR::is_a(*caller_type)) { + if (ASR::is_a(*caller_type)) { struct_sym = ASRUtils::symbol_get_past_external( - ASR::down_cast(caller_type)->m_derived_type); + ASR::down_cast(caller_type)->m_derived_type); } else if (ASR::is_a(*caller_type)) { struct_sym = ASRUtils::symbol_get_past_external( ASR::down_cast(caller_type)->m_class_type); @@ -1508,8 +1508,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::Variable_t* member_var = ASR::down_cast( ASRUtils::symbol_get_past_external(x.m_m)); ASR::ttype_t* member_type_asr = ASRUtils::get_contained_type(member_var->m_type); - if( ASR::is_a(*member_type_asr) ) { - ASR::Struct_t* d = ASR::down_cast(member_type_asr); + if( ASR::is_a(*member_type_asr) ) { + ASR::StructType_t* d = ASR::down_cast(member_type_asr); current_der_type_name = ASRUtils::symbol_name(d->m_derived_type); } member_type_asr = member_var->m_type; @@ -2319,8 +2319,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor array = tmp; } - if( ASR::is_a(*ASRUtils::extract_type(x.m_type)) ) { - ASR::Struct_t* der_type = ASR::down_cast( + if( ASR::is_a(*ASRUtils::extract_type(x.m_type)) ) { + ASR::StructType_t* der_type = ASR::down_cast( ASRUtils::extract_type(x.m_type)); current_der_type_name = ASRUtils::symbol_name( ASRUtils::symbol_get_past_external(der_type->m_derived_type)); @@ -2653,8 +2653,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor tmp = llvm_utils->create_gep(tmp, member_idx); ASR::ttype_t* member_type = ASRUtils::type_get_past_pointer( ASRUtils::type_get_past_allocatable(member->m_type)); - if( ASR::is_a(*member_type) ) { - ASR::symbol_t *s_sym = ASR::down_cast( + if( ASR::is_a(*member_type) ) { + ASR::symbol_t *s_sym = ASR::down_cast( member_type)->m_derived_type; current_der_type_name = ASRUtils::symbol_name( ASRUtils::symbol_get_past_external(s_sym)); @@ -2791,8 +2791,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } llvm_symtab[h] = ptr; - } else if( x.m_type->type == ASR::ttypeType::Struct ) { - ASR::Struct_t* struct_t = ASR::down_cast(x.m_type); + } else if( x.m_type->type == ASR::ttypeType::StructType ) { + ASR::StructType_t* struct_t = ASR::down_cast(x.m_type); if( ASRUtils::is_c_ptr(struct_t->m_derived_type) ) { llvm::Type* void_ptr = llvm::Type::getVoidTy(context)->getPointerTo(); llvm::Constant *ptr = module->getOrInsertGlobal(x.m_name, @@ -3221,9 +3221,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } \ void allocate_array_members_of_struct(llvm::Value* ptr, ASR::ttype_t* asr_type) { - LCOMPILERS_ASSERT(ASR::is_a(*asr_type)); - ASR::Struct_t* struct_t = ASR::down_cast(asr_type); - ASR::StructType_t* struct_type_t = ASR::down_cast( + LCOMPILERS_ASSERT(ASR::is_a(*asr_type)); + ASR::StructType_t* struct_t = ASR::down_cast(asr_type); + ASR::Struct_t* struct_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); std::string struct_type_name = struct_type_t->m_name; for( auto item: struct_type_t->m_symtab->get_scope() ) { @@ -3234,7 +3234,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor if( ASR::is_a(*sym) || ASR::is_a(*sym) || ASR::is_a(*sym) || - ASR::is_a(*sym) || + ASR::is_a(*sym) || ASR::is_a(*sym) ) { continue ; } @@ -3280,7 +3280,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } else { fill_array_details_(ptr_member, nullptr, m_dims, n_dims, false, true, false, symbol_type, is_data_only); } - } else if( ASR::is_a(*symbol_type) ) { + } else if( ASR::is_a(*symbol_type) ) { allocate_array_members_of_struct(ptr_member, symbol_type); } } @@ -3361,8 +3361,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } void create_vtab_for_struct_type(ASR::symbol_t* struct_type_sym, SymbolTable* symtab) { - LCOMPILERS_ASSERT(ASR::is_a(*struct_type_sym)); - ASR::StructType_t* struct_type_t = ASR::down_cast(struct_type_sym); + LCOMPILERS_ASSERT(ASR::is_a(*struct_type_sym)); + ASR::Struct_t* struct_type_t = ASR::down_cast(struct_type_sym); if( type2vtab.find(struct_type_sym) != type2vtab.end() && type2vtab[struct_type_sym].find(symtab) != type2vtab[struct_type_sym].end() ) { return ; @@ -3384,8 +3384,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::symbol_t* struct_type_ = struct_type_sym; bool base_found = false; while( !base_found ) { - if( ASR::is_a(*struct_type_) ) { - ASR::StructType_t* struct_type = ASR::down_cast(struct_type_); + if( ASR::is_a(*struct_type_) ) { + ASR::Struct_t* struct_type = ASR::down_cast(struct_type_); if( struct_type->m_parent == nullptr ) { base_found = true; } else { @@ -3414,7 +3414,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::Class_t* v_class_t = ASR::down_cast(v_type); class_type_names.insert(ASRUtils::symbol_name(v_class_t->m_class_type)); } - } else if (ASR::is_a( + } else if (ASR::is_a( *ASRUtils::symbol_get_past_external(var_sym))) { struct_types.push_back(var_sym); } @@ -3441,7 +3441,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor if( struct_type == class_sym ) { is_vtab_needed = true; } else { - struct_type = ASR::down_cast( + struct_type = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_type))->m_parent; } } @@ -3553,7 +3553,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } set_pointer_variable_to_null(llvm::ConstantPointerNull::get( static_cast(type)), ptr) - if( ASR::is_a( + if( ASR::is_a( *ASRUtils::type_get_past_array(v->m_type)) ) { if( ASRUtils::is_array(v->m_type) ) { allocate_array_members_of_struct_arrays(ptr, v->m_type); @@ -3583,9 +3583,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor line, 0, debug_current_scope), builder->GetInsertBlock()); } - if( ASR::is_a(*v->m_type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(v->m_type); - ASR::StructType_t* struct_type = ASR::down_cast( + if( ASR::is_a(*v->m_type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(v->m_type); + ASR::Struct_t* struct_type = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); int64_t alignment_value = -1; if( ASRUtils::extract_value(struct_type->m_alignment, alignment_value) ) { @@ -4433,7 +4433,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor if( is_target_class && !is_value_class ) { llvm::Value* vtab_address_ptr = llvm_utils->create_gep(llvm_target, 0); llvm_target = llvm_utils->create_gep(llvm_target, 1); - ASR::Struct_t* struct_t = ASR::down_cast( + ASR::StructType_t* struct_t = ASR::down_cast( ASRUtils::type_get_past_pointer(value_type)); ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); if (type2vtab.find(struct_sym) == type2vtab.end() || @@ -4446,7 +4446,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::Class_t* class_t = ASR::down_cast( ASRUtils::type_get_past_pointer(target_type)); - ASR::StructType_t* struct_type_t = ASR::down_cast( + ASR::Struct_t* struct_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(class_t->m_class_type)); llvm_value = builder->CreateBitCast(llvm_value, llvm_utils->getStructType(struct_type_t, module.get(), true)); builder->CreateStore(llvm_value, llvm_target); @@ -4607,8 +4607,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor bool is_value_dict = ASR::is_a(*asr_value_type); bool is_target_set = ASR::is_a(*asr_target_type); bool is_value_set = ASR::is_a(*asr_value_type); - bool is_target_struct = ASR::is_a(*asr_target_type); - bool is_value_struct = ASR::is_a(*asr_value_type); + bool is_target_struct = ASR::is_a(*asr_target_type); + bool is_value_struct = ASR::is_a(*asr_value_type); bool is_value_list_to_array = (ASR::is_a(*x.m_value) && ASR::down_cast(x.m_value)->m_kind == ASR::cast_kindType::ListToArray); if (ASR::is_a(*x.m_target)) { @@ -4884,7 +4884,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor tmp = LLVM::CreateLoad(*builder, tmp); } value = tmp; - if (ASR::is_a(*target_type)) { + if (ASR::is_a(*target_type)) { if (value->getType()->isPointerTy()) { value = LLVM::CreateLoad(*builder, value); } @@ -5346,10 +5346,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } ASR::TypeStmtName_t* type_stmt_name = ASR::down_cast(select_type_stmts[i]); ASR::symbol_t* type_sym = ASRUtils::symbol_get_past_external(type_stmt_name->m_sym); - if( ASR::is_a(*type_sym) ) { + if( ASR::is_a(*type_sym) ) { current_select_type_block_type = llvm_utils->getStructType( - ASR::down_cast(type_sym), module.get(), true); - current_select_type_block_der_type = ASR::down_cast(type_sym)->m_name; + ASR::down_cast(type_sym), module.get(), true); + current_select_type_block_der_type = ASR::down_cast(type_sym)->m_name; } else { LCOMPILERS_ASSERT(false); } @@ -5369,10 +5369,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor llvm::Value* vptr_int_hash = CreateLoad(llvm_utils->create_gep(llvm_selector, 0)); ASR::ClassStmt_t* class_stmt = ASR::down_cast(select_type_stmts[i]); ASR::symbol_t* class_sym = ASRUtils::symbol_get_past_external(class_stmt->m_sym); - if( ASR::is_a(*class_sym) ) { + if( ASR::is_a(*class_sym) ) { current_select_type_block_type = llvm_utils->getStructType( - ASR::down_cast(class_sym), module.get(), true); - current_select_type_block_der_type = ASR::down_cast(class_sym)->m_name; + ASR::down_cast(class_sym), module.get(), true); + current_select_type_block_der_type = ASR::down_cast(class_sym)->m_name; } else { LCOMPILERS_ASSERT(false); } @@ -6721,12 +6721,12 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor case ASR::ttypeType::UnsignedInteger: case ASR::ttypeType::Real: case ASR::ttypeType::Complex: - case ASR::ttypeType::Struct: + case ASR::ttypeType::StructType: case ASR::ttypeType::Character: case ASR::ttypeType::Logical: case ASR::ttypeType::Class: { - if( t2->type == ASR::ttypeType::Struct ) { - ASR::Struct_t* d = ASR::down_cast(t2); + if( t2->type == ASR::ttypeType::StructType ) { + ASR::StructType_t* d = ASR::down_cast(t2); current_der_type_name = ASRUtils::symbol_name(d->m_derived_type); } else if( t2->type == ASR::ttypeType::Class ) { ASR::Class_t* d = ASR::down_cast(t2); @@ -6740,9 +6740,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } break; } - case ASR::ttypeType::Struct: { - ASR::Struct_t* der = ASR::down_cast(t2_); - ASR::StructType_t* der_type = ASR::down_cast( + case ASR::ttypeType::StructType: { + ASR::StructType_t* der = ASR::down_cast(t2_); + ASR::Struct_t* der_type = ASR::down_cast( ASRUtils::symbol_get_past_external(der->m_derived_type)); current_der_type_name = std::string(der_type->m_name); uint32_t h = get_hash((ASR::asr_t*)x); @@ -6768,8 +6768,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor if( ASR::is_a(*der_sym) ) { ASR::ClassType_t* der_type = ASR::down_cast(der_sym); current_der_type_name = std::string(der_type->m_name); - } else if( ASR::is_a(*der_sym) ) { - ASR::StructType_t* der_type = ASR::down_cast(der_sym); + } else if( ASR::is_a(*der_sym) ) { + ASR::Struct_t* der_type = ASR::down_cast(der_sym); current_der_type_name = std::string(der_type->m_name); } uint32_t h = get_hash((ASR::asr_t*)x); @@ -8433,7 +8433,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor case (ASR::ttypeType::Enum) : target_type = llvm::Type::getInt32Ty(context); break; - case (ASR::ttypeType::Struct) : + case (ASR::ttypeType::StructType) : break; case (ASR::ttypeType::CPtr) : target_type = llvm::Type::getVoidTy(context)->getPointerTo(); @@ -8466,7 +8466,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor target_type = llvm::Type::getInt32Ty(context); } switch(arg_type->type) { - case ASR::ttypeType::Struct: { + case ASR::ttypeType::StructType: { tmp = value; break; } @@ -8655,15 +8655,15 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor builder->CreateBitCast(dt, llvm::Type::getVoidTy(context)->getPointerTo()), polymorphic_addr); llvm::Value* type_id_addr = llvm_utils->create_gep(abstract_, 0); - ASR::Struct_t* struct_t = ASR::down_cast(arg_type); + ASR::StructType_t* struct_t = ASR::down_cast(arg_type); ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); llvm::Value* hash = llvm::ConstantInt::get(llvm_utils->getIntType(8), llvm::APInt(64, get_class_hash(struct_sym))); builder->CreateStore(hash, type_id_addr); return abstract_; } - } else if( ASR::is_a(*ASRUtils::type_get_past_array(arg_type)) ) { - ASR::Struct_t* struct_t = ASR::down_cast(ASRUtils::type_get_past_array(arg_type)); + } else if( ASR::is_a(*ASRUtils::type_get_past_array(arg_type)) ) { + ASR::StructType_t* struct_t = ASR::down_cast(ASRUtils::type_get_past_array(arg_type)); ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); if( type2vtab.find(struct_sym) == type2vtab.end() && type2vtab[struct_sym].find(current_scope) == type2vtab[struct_sym].end() ) { @@ -8771,7 +8771,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor // Get struct symbol ASR::ttype_t *arg_type = struct_mem->m_type; - ASR::Struct_t* struct_t = ASR::down_cast( + ASR::StructType_t* struct_t = ASR::down_cast( ASRUtils::type_get_past_allocatable( ASRUtils::type_get_past_array(arg_type))); ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external( @@ -8813,7 +8813,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor pass_arg = dt_polymorphic; } } else { - throw CodeGenError("SubroutineCall: Struct symbol type not supported"); + throw CodeGenError("SubroutineCall: StructType symbol type not supported"); } } @@ -8969,7 +8969,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } - llvm::Value* CreatePointerToStructReturnValue(llvm::FunctionType* fnty, + llvm::Value* CreatePointerToStructTypeReturnValue(llvm::FunctionType* fnty, llvm::Value* return_value, ASR::ttype_t* asr_return_type) { if( !LLVM::is_llvm_struct(asr_return_type) ) { @@ -8987,7 +8987,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor std::vector& args, ASR::ttype_t* asr_return_type) { llvm::Value* return_value = builder->CreateCall(fn, args); - return CreatePointerToStructReturnValue(fnty, return_value, + return CreatePointerToStructTypeReturnValue(fnty, return_value, asr_return_type); } @@ -8998,21 +8998,21 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor void visit_RuntimePolymorphicSubroutineCall(const ASR::SubroutineCall_t& x, std::string proc_sym_name) { std::vector> vtabs; - ASR::StructType_t* dt_sym_type = nullptr; + ASR::Struct_t* dt_sym_type = nullptr; ASR::ttype_t* dt_ttype_t = ASRUtils::type_get_past_allocatable(ASRUtils::type_get_past_pointer( ASRUtils::expr_type(x.m_dt))); - if( ASR::is_a(*dt_ttype_t) ) { - ASR::Struct_t* struct_t = ASR::down_cast(dt_ttype_t); - dt_sym_type = ASR::down_cast( + if( ASR::is_a(*dt_ttype_t) ) { + ASR::StructType_t* struct_t = ASR::down_cast(dt_ttype_t); + dt_sym_type = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); } else if( ASR::is_a(*dt_ttype_t) ) { ASR::Class_t* class_t = ASR::down_cast(dt_ttype_t); - dt_sym_type = ASR::down_cast( + dt_sym_type = ASR::down_cast( ASRUtils::symbol_get_past_external(class_t->m_class_type)); } LCOMPILERS_ASSERT(dt_sym_type != nullptr); for( auto& item: type2vtab ) { - ASR::StructType_t* a_dt = ASR::down_cast(item.first); + ASR::Struct_t* a_dt = ASR::down_cast(item.first); if( !a_dt->m_is_abstract && (a_dt == dt_sym_type || ASRUtils::is_parent(a_dt, dt_sym_type) || @@ -9054,7 +9054,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor builder->SetInsertPoint(thenBB); { std::vector args; - ASR::StructType_t* struct_type_t = ASR::down_cast(type_sym); + ASR::Struct_t* struct_type_t = ASR::down_cast(type_sym); llvm::Type* target_dt_type = llvm_utils->getStructType(struct_type_t, module.get(), true); llvm::Type* target_class_dt_type = llvm_utils->getClassType(struct_type_t); llvm::Value* target_dt = builder->CreateAlloca(target_class_dt_type); @@ -9084,21 +9084,21 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor void visit_RuntimePolymorphicFunctionCall(const ASR::FunctionCall_t& x, std::string proc_sym_name) { std::vector> vtabs; - ASR::StructType_t* dt_sym_type = nullptr; + ASR::Struct_t* dt_sym_type = nullptr; ASR::ttype_t* dt_ttype_t = ASRUtils::type_get_past_allocatable(ASRUtils::type_get_past_pointer( ASRUtils::expr_type(x.m_dt))); - if( ASR::is_a(*dt_ttype_t) ) { - ASR::Struct_t* struct_t = ASR::down_cast(dt_ttype_t); - dt_sym_type = ASR::down_cast( + if( ASR::is_a(*dt_ttype_t) ) { + ASR::StructType_t* struct_t = ASR::down_cast(dt_ttype_t); + dt_sym_type = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); } else if( ASR::is_a(*dt_ttype_t) ) { ASR::Class_t* class_t = ASR::down_cast(dt_ttype_t); - dt_sym_type = ASR::down_cast( + dt_sym_type = ASR::down_cast( ASRUtils::symbol_get_past_external(class_t->m_class_type)); } LCOMPILERS_ASSERT(dt_sym_type != nullptr); for( auto& item: type2vtab ) { - ASR::StructType_t* a_dt = ASR::down_cast(item.first); + ASR::Struct_t* a_dt = ASR::down_cast(item.first); if( !a_dt->m_is_abstract && (a_dt == dt_sym_type || ASRUtils::is_parent(a_dt, dt_sym_type) || @@ -9141,7 +9141,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor builder->SetInsertPoint(thenBB); { std::vector args; - ASR::StructType_t* struct_type_t = ASR::down_cast(type_sym); + ASR::Struct_t* struct_type_t = ASR::down_cast(type_sym); llvm::Type* target_dt_type = llvm_utils->getStructType(struct_type_t, module.get(), true); llvm::Type* target_class_dt_type = llvm_utils->getClassType(struct_type_t); llvm::Value* target_dt = builder->CreateAlloca(target_class_dt_type); @@ -9273,8 +9273,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor arg_type = ASRUtils::type_get_past_allocatable( ASRUtils::type_get_past_array(arg_type)); ASR::symbol_t* struct_sym = nullptr; - if (ASR::is_a(*arg_type)) { - ASR::Struct_t* struct_t = ASR::down_cast(arg_type); + if (ASR::is_a(*arg_type)) { + ASR::StructType_t* struct_t = ASR::down_cast(arg_type); struct_sym = ASRUtils::symbol_get_past_external( struct_t->m_derived_type); } else if (ASR::is_a(*arg_type)) { @@ -9305,9 +9305,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor llvm_utils->getIntType(8), llvm::APInt(64, get_class_hash(struct_sym))); builder->CreateStore(hash, hash_ptr); - if (ASR::is_a(*caller_type)) { + if (ASR::is_a(*caller_type)) { struct_sym = ASRUtils::symbol_get_past_external( - ASR::down_cast(caller_type)->m_derived_type); + ASR::down_cast(caller_type)->m_derived_type); } else if (ASR::is_a(*caller_type)) { struct_sym = ASRUtils::symbol_get_past_external( ASR::down_cast(caller_type)->m_class_type); @@ -9327,7 +9327,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor pass_arg = dt_polymorphic; } } else { - throw CodeGenError("FunctionCall: Struct symbol type not supported"); + throw CodeGenError("FunctionCall: StructType symbol type not supported"); } } if( ASRUtils::is_intrinsic_function2(s) ) { diff --git a/src/libasr/codegen/c_utils.h b/src/libasr/codegen/c_utils.h index feff3acf57..5bd81063b8 100644 --- a/src/libasr/codegen/c_utils.h +++ b/src/libasr/codegen/c_utils.h @@ -44,7 +44,7 @@ namespace LCompilers { namespace CUtils { static inline bool is_non_primitive_DT(ASR::ttype_t *t) { - return ASR::is_a(*t) || ASR::is_a(*t) || ASR::is_a(*t); + return ASR::is_a(*t) || ASR::is_a(*t) || ASR::is_a(*t); } class CUtilFunctions { @@ -245,7 +245,7 @@ namespace CUtils { return result; } - static inline std::string get_struct_type_code(ASR::Struct_t* struct_t) { + static inline std::string get_struct_type_code(ASR::StructType_t* struct_t) { return ASRUtils::symbol_name(struct_t->m_derived_type); } @@ -294,8 +294,8 @@ namespace CUtils { type_src = "void*"; break; } - case ASR::ttypeType::Struct: { - ASR::Struct_t* der_type = ASR::down_cast(t); + case ASR::ttypeType::StructType: { + ASR::StructType_t* der_type = ASR::down_cast(t); type_src = std::string("struct ") + ASRUtils::symbol_name(der_type->m_derived_type); break; } @@ -417,7 +417,7 @@ class CCPPDSUtils { } break; } - case ASR::ttypeType::Struct: { + case ASR::ttypeType::StructType: { std::string func = get_struct_deepcopy_func(t); result = func + "(" + value + ", " + target + ");"; break; @@ -602,7 +602,7 @@ class CCPPDSUtils { } std::string get_struct_deepcopy_func(ASR::ttype_t* struct_type_asr) { - ASR::Struct_t* struct_type = ASR::down_cast(struct_type_asr); + ASR::StructType_t* struct_type = ASR::down_cast(struct_type_asr); std::string struct_type_code = CUtils::get_struct_type_code(struct_type); if( typecodeToDSfuncs.find(struct_type_code) == typecodeToDSfuncs.end() ) { struct_deepcopy(struct_type_asr); @@ -832,8 +832,8 @@ class CCPPDSUtils { } void struct_deepcopy(ASR::ttype_t* struct_type_asr) { - ASR::Struct_t* struct_type = ASR::down_cast(struct_type_asr); - ASR::StructType_t* struct_type_t = ASR::down_cast( + ASR::StructType_t* struct_type = ASR::down_cast(struct_type_asr); + ASR::Struct_t* struct_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_type->m_derived_type)); std::string struct_type_code = CUtils::get_struct_type_code(struct_type); std::string indent(indentation_level * indentation_spaces, ' '); diff --git a/src/libasr/codegen/llvm_utils.cpp b/src/libasr/codegen/llvm_utils.cpp index 7a317e04c1..9f20c98f78 100644 --- a/src/libasr/codegen/llvm_utils.cpp +++ b/src/libasr/codegen/llvm_utils.cpp @@ -159,7 +159,7 @@ namespace LCompilers { llvm_mem_type = getFPType(a_kind); break; } - case ASR::ttypeType::Struct: { + case ASR::ttypeType::StructType: { llvm_mem_type = getStructType(mem_type, module); break; } @@ -203,7 +203,7 @@ namespace LCompilers { return llvm_mem_type; } - void LLVMUtils::createStructContext(ASR::StructType_t* der_type) { + void LLVMUtils::createStructTypeContext(ASR::Struct_t* der_type) { std::string der_type_name = std::string(der_type->m_name); if (name2dercontext.find(der_type_name) == name2dercontext.end() ) { llvm::StructType* der_type_llvm = llvm::StructType::create(context, @@ -212,24 +212,24 @@ namespace LCompilers { der_type->m_is_packed); name2dercontext[der_type_name] = der_type_llvm; if( der_type->m_parent != nullptr ) { - ASR::StructType_t *par_der_type = ASR::down_cast( + ASR::Struct_t *par_der_type = ASR::down_cast( ASRUtils::symbol_get_past_external(der_type->m_parent)); - createStructContext(par_der_type); + createStructTypeContext(par_der_type); } for( size_t i = 0; i < der_type->n_members; i++ ) { std::string member_name = der_type->m_members[i]; ASR::symbol_t* sym = der_type->m_symtab->get_symbol(member_name); - if (ASR::is_a(*sym)) { - ASR::StructType_t *d_type = ASR::down_cast(sym); - createStructContext(d_type); + if (ASR::is_a(*sym)) { + ASR::Struct_t *d_type = ASR::down_cast(sym); + createStructTypeContext(d_type); } } } } - llvm::Type* LLVMUtils::getStructType(ASR::StructType_t* der_type, llvm::Module* module, bool is_pointer) { + llvm::Type* LLVMUtils::getStructType(ASR::Struct_t* der_type, llvm::Module* module, bool is_pointer) { std::string der_type_name = std::string(der_type->m_name); - createStructContext(der_type); + createStructTypeContext(der_type); if (std::find(struct_type_stack.begin(), struct_type_stack.end(), der_type_name) != struct_type_stack.end()) { LCOMPILERS_ASSERT(name2dercontext.find(der_type_name) != name2dercontext.end()); @@ -244,7 +244,7 @@ namespace LCompilers { std::vector member_types; int member_idx = 0; if( der_type->m_parent != nullptr ) { - ASR::StructType_t *par_der_type = ASR::down_cast( + ASR::Struct_t *par_der_type = ASR::down_cast( ASRUtils::symbol_get_past_external(der_type->m_parent)); llvm::Type* par_llvm = getStructType(par_der_type, module); member_types.push_back(par_llvm); @@ -270,15 +270,15 @@ namespace LCompilers { } llvm::Type* LLVMUtils::getStructType(ASR::ttype_t* _type, llvm::Module* module, bool is_pointer) { - ASR::StructType_t* der_type; - if( ASR::is_a(*_type) ) { - ASR::Struct_t* der = ASR::down_cast(_type); + ASR::Struct_t* der_type; + if( ASR::is_a(*_type) ) { + ASR::StructType_t* der = ASR::down_cast(_type); ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_derived_type); - der_type = ASR::down_cast(der_sym); + der_type = ASR::down_cast(der_sym); } else if( ASR::is_a(*_type) ) { ASR::Class_t* der = ASR::down_cast(_type); ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_class_type); - der_type = ASR::down_cast(der_sym); + der_type = ASR::down_cast(der_sym); } else { LCOMPILERS_ASSERT(false); return nullptr; // silence a warning @@ -373,7 +373,7 @@ namespace LCompilers { return (llvm::Type*) der_type_llvm; } - llvm::Type* LLVMUtils::getClassType(ASR::StructType_t* der_type, bool is_pointer) { + llvm::Type* LLVMUtils::getClassType(ASR::Struct_t* der_type, bool is_pointer) { std::string der_type_name = std::string(der_type->m_name) + std::string("_polymorphic"); llvm::StructType* der_type_llvm = nullptr; if( name2dertype.find(der_type_name) != name2dertype.end() ) { @@ -402,8 +402,8 @@ namespace LCompilers { } else if( ASR::is_a(*der_sym) ) { ASR::ClassType_t* class_type_t = ASR::down_cast(der_sym); member_types.push_back(getClassType(class_type_t, is_pointer)); - } else if( ASR::is_a(*der_sym) ) { - ASR::StructType_t* struct_type_t = ASR::down_cast(der_sym); + } else if( ASR::is_a(*der_sym) ) { + ASR::Struct_t* struct_type_t = ASR::down_cast(der_sym); member_types.push_back(getStructType(struct_type_t, module, is_pointer)); } der_type_llvm = llvm::StructType::create(context, member_types, der_type_name); @@ -491,7 +491,7 @@ namespace LCompilers { el_type = llvm::Type::getInt1Ty(context); break; } - case ASR::ttypeType::Struct: { + case ASR::ttypeType::StructType: { el_type = getStructType(m_type_, module); break; } @@ -762,7 +762,7 @@ namespace LCompilers { } break; } - case (ASR::ttypeType::Struct) : { + case (ASR::ttypeType::StructType) : { type = getStructType(asr_type, module, true); break; } @@ -1018,7 +1018,7 @@ namespace LCompilers { return_type = get_type_from_ttype_t_util(ASRUtils::get_contained_type(return_var_type0), module); break; } - case (ASR::ttypeType::Struct) : + case (ASR::ttypeType::StructType) : throw CodeGenError("Struct return type not implemented yet"); break; case (ASR::ttypeType::Tuple) : { @@ -1216,7 +1216,7 @@ namespace LCompilers { return_type = get_type_from_ttype_t_util(ASRUtils::get_contained_type(return_var_type0), module); break; } - case (ASR::ttypeType::Struct) : + case (ASR::ttypeType::StructType) : throw CodeGenError("Struct return type not implemented yet"); break; case (ASR::ttypeType::Tuple) : { @@ -1426,7 +1426,7 @@ namespace LCompilers { llvm_type = llvm::Type::getInt1Ty(context); break; } - case (ASR::ttypeType::Struct) : { + case (ASR::ttypeType::StructType) : { llvm_type = getStructType(asr_type, module, false); break; } @@ -1945,9 +1945,9 @@ namespace LCompilers { dict_api->dict_deepcopy(src, dest, dict_type, module, name2memidx); break ; } - case ASR::ttypeType::Struct: { - ASR::Struct_t* struct_t = ASR::down_cast(asr_type); - ASR::StructType_t* struct_type_t = ASR::down_cast( + case ASR::ttypeType::StructType: { + ASR::StructType_t* struct_t = ASR::down_cast(asr_type); + ASR::Struct_t* struct_type_t = ASR::down_cast( ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); std::string der_type_name = std::string(struct_type_t->m_name); while( struct_type_t != nullptr ) { @@ -1969,8 +1969,8 @@ namespace LCompilers { module, name2memidx); } if( struct_type_t->m_parent != nullptr ) { - ASR::StructType_t* parent_struct_type_t = - ASR::down_cast(struct_type_t->m_parent); + ASR::Struct_t* parent_struct_type_t = + ASR::down_cast(struct_type_t->m_parent); struct_type_t = parent_struct_type_t; } else { struct_type_t = nullptr; diff --git a/src/libasr/codegen/llvm_utils.h b/src/libasr/codegen/llvm_utils.h index 0ea2644e96..8e24438100 100644 --- a/src/libasr/codegen/llvm_utils.h +++ b/src/libasr/codegen/llvm_utils.h @@ -180,7 +180,7 @@ namespace LCompilers { static inline bool is_llvm_struct(ASR::ttype_t* asr_type) { return ASR::is_a(*asr_type) || ASR::is_a(*asr_type) || - ASR::is_a(*asr_type) || + ASR::is_a(*asr_type) || ASR::is_a(*asr_type)|| ASR::is_a(*asr_type); } @@ -269,9 +269,9 @@ namespace LCompilers { llvm::Type* getMemberType(ASR::ttype_t* mem_type, ASR::Variable_t* member, llvm::Module* module); - void createStructContext(ASR::StructType_t* der_type); + void createStructTypeContext(ASR::Struct_t* der_type); - llvm::Type* getStructType(ASR::StructType_t* der_type, llvm::Module* module, bool is_pointer=false); + llvm::Type* getStructType(ASR::Struct_t* der_type, llvm::Module* module, bool is_pointer=false); llvm::Type* getStructType(ASR::ttype_t* _type, llvm::Module* module, bool is_pointer=false); @@ -283,7 +283,7 @@ namespace LCompilers { llvm::Type* getClassType(ASR::ClassType_t* der_type, bool is_pointer=false); - llvm::Type* getClassType(ASR::StructType_t* der_type, bool is_pointer=false); + llvm::Type* getClassType(ASR::Struct_t* der_type, bool is_pointer=false); llvm::Type* getClassType(ASR::ttype_t* _type, bool is_pointer=false); diff --git a/src/libasr/codegen/wasm_decoder.h b/src/libasr/codegen/wasm_decoder.h index c42405ad16..5e7544446c 100644 --- a/src/libasr/codegen/wasm_decoder.h +++ b/src/libasr/codegen/wasm_decoder.h @@ -40,10 +40,10 @@ class CodeGenError { namespace wasm { -template +template class WASMDecoder { private: - Struct &self() { return static_cast(*this); } + StructType &self() { return static_cast(*this); } public: Allocator &al; diff --git a/src/libasr/pass/class_constructor.cpp b/src/libasr/pass/class_constructor.cpp index da410efae6..d79bdd264c 100644 --- a/src/libasr/pass/class_constructor.cpp +++ b/src/libasr/pass/class_constructor.cpp @@ -14,7 +14,7 @@ namespace LCompilers { using ASR::down_cast; using ASR::is_a; -class ReplaceStructTypeConstructor: public ASR::BaseExprReplacer { +class ReplaceStructConstructor: public ASR::BaseExprReplacer { public: @@ -25,31 +25,31 @@ class ReplaceStructTypeConstructor: public ASR::BaseExprReplacer& pass_result_, + ReplaceStructConstructor(Allocator& al_, Vec& pass_result_, bool& remove_original_statement_) : al(al_), pass_result(pass_result_), remove_original_statement(remove_original_statement_), current_scope(nullptr), result_var(nullptr) {} - void replace_StructTypeConstructor(ASR::StructTypeConstructor_t* x) { + void replace_StructConstructor(ASR::StructConstructor_t* x) { Vec* result_vec = &pass_result; - PassUtils::ReplacerUtils::replace_StructTypeConstructor( + PassUtils::ReplacerUtils::replace_StructConstructor( x, this, false, remove_original_statement, result_vec); } }; -class StructTypeConstructorVisitor : public ASR::CallReplacerOnExpressionsVisitor +class StructConstructorVisitor : public ASR::CallReplacerOnExpressionsVisitor { private: Allocator& al; bool remove_original_statement; - ReplaceStructTypeConstructor replacer; + ReplaceStructConstructor replacer; Vec pass_result; public: - StructTypeConstructorVisitor(Allocator& al_) : + StructConstructorVisitor(Allocator& al_) : al(al_), remove_original_statement(false), replacer(al_, pass_result, remove_original_statement) { pass_result.n = 0; @@ -113,7 +113,7 @@ class StructTypeConstructorVisitor : public ASR::CallReplacerOnExpressionsVisito void pass_replace_class_constructor(Allocator &al, ASR::TranslationUnit_t &unit, const LCompilers::PassOptions& /*pass_options*/) { - StructTypeConstructorVisitor v(al); + StructConstructorVisitor v(al); v.visit_TranslationUnit(unit); PassUtils::UpdateDependenciesVisitor w(al); w.visit_TranslationUnit(unit); diff --git a/src/libasr/pass/init_expr.cpp b/src/libasr/pass/init_expr.cpp index 0ee4c67a12..83e62b5276 100644 --- a/src/libasr/pass/init_expr.cpp +++ b/src/libasr/pass/init_expr.cpp @@ -69,7 +69,7 @@ class ReplaceInitExpr: public ASR::BaseExprReplacer { *current_expr = nullptr; } - void replace_StructTypeConstructor(ASR::StructTypeConstructor_t* x) { + void replace_StructConstructor(ASR::StructConstructor_t* x) { if( symtab2decls.find(current_scope) == symtab2decls.end() ) { Vec result_vec_; result_vec_.reserve(al, 0); @@ -77,7 +77,7 @@ class ReplaceInitExpr: public ASR::BaseExprReplacer { } Vec* result_vec = &symtab2decls[current_scope]; bool remove_original_statement = false; - PassUtils::ReplacerUtils::replace_StructTypeConstructor( + PassUtils::ReplacerUtils::replace_StructConstructor( x, this, true, remove_original_statement, result_vec, perform_cast, cast_kind, casted_type); *current_expr = nullptr; @@ -182,7 +182,7 @@ class InitExprVisitor : public ASR::CallReplacerOnExpressionsVisitor(*symbolic_value) || - ASR::is_a(*symbolic_value) || + ASR::is_a(*symbolic_value) || ASR::is_a(*symbolic_value))) || (ASR::is_a(*asr_owner) && (ASR::is_a(*symbolic_value) || diff --git a/src/libasr/pass/inline_function_calls.cpp b/src/libasr/pass/inline_function_calls.cpp index 8454cfa01c..9ec9e8a93a 100644 --- a/src/libasr/pass/inline_function_calls.cpp +++ b/src/libasr/pass/inline_function_calls.cpp @@ -313,7 +313,7 @@ class InlineFunctionCall : public ASR::BaseExprReplacer if( !ASR::is_a(*itr.second) || ASRUtils::is_character(*ASRUtils::symbol_type(itr.second)) || ASRUtils::is_array(ASRUtils::symbol_type(itr.second)) || - ASR::is_a(*ASRUtils::symbol_type(itr.second)) || + ASR::is_a(*ASRUtils::symbol_type(itr.second)) || ASR::is_a(*ASRUtils::symbol_type(itr.second)) ) { arg2value.clear(); return ; diff --git a/src/libasr/pass/instantiate_template.cpp b/src/libasr/pass/instantiate_template.cpp index aa3576c5e2..572dadaa11 100644 --- a/src/libasr/pass/instantiate_template.cpp +++ b/src/libasr/pass/instantiate_template.cpp @@ -184,9 +184,9 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator(x); return instantiate_Function(f); } - case (ASR::symbolType::StructType) : { - ASR::StructType_t *s = ASR::down_cast(x); - return instantiate_StructType(s); + case (ASR::symbolType::Struct) : { + ASR::Struct_t *s = ASR::down_cast(x); + return instantiate_Struct(s); } default : { std::string sym_name = ASRUtils::symbol_name(x); @@ -314,7 +314,7 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator(func_scope); for (auto const &sym_pair: x->m_symtab->get_scope()) { if (ASR::is_a(*sym_pair.second)) { @@ -330,7 +330,7 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicatorm_alignment); - ASR::asr_t *result = ASR::make_StructType_t(al, x->base.base.loc, + ASR::asr_t *result = ASR::make_Struct_t(al, x->base.base.loc, current_scope, s2c(al, new_sym_name), nullptr, 0, data_member_names.p, data_member_names.size(), @@ -687,14 +687,14 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicatorbase.loc, substitute_type(tlist->m_type))); } - case (ASR::ttypeType::Struct) : { - ASR::Struct_t *s = ASR::down_cast(ttype); + case (ASR::ttypeType::StructType) : { + ASR::StructType_t *s = ASR::down_cast(ttype); std::string struct_name = ASRUtils::symbol_name(s->m_derived_type); if (context_map.find(struct_name) != context_map.end()) { std::string new_struct_name = context_map[struct_name]; ASR::symbol_t *sym = func_scope->resolve_symbol(new_struct_name); return ASRUtils::TYPE( - ASR::make_Struct_t(al, s->base.base.loc, sym)); + ASR::make_StructType_t(al, s->base.base.loc, sym)); } else { return ttype; } @@ -1124,9 +1124,9 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator(sym); return instantiate_Template(x); } - case (ASR::symbolType::StructType) : { - ASR::StructType_t* x = ASR::down_cast(sym); - return instantiate_StructType(x); + case (ASR::symbolType::Struct) : { + ASR::Struct_t* x = ASR::down_cast(sym); + return instantiate_Struct(x); } case (ASR::symbolType::ExternalSymbol) : { ASR::ExternalSymbol_t* x = ASR::down_cast(sym); @@ -1246,7 +1246,7 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicator(target_scope); Vec data_member_names; @@ -1257,7 +1257,7 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicatorm_alignment); - ASR::asr_t* result = ASR::make_StructType_t(al, x->base.base.loc, + ASR::asr_t* result = ASR::make_Struct_t(al, x->base.base.loc, new_scope, s2c(al, new_sym_name), nullptr, 0, data_member_names.p, data_member_names.size(), x->m_abi, x->m_access, x->m_is_packed, x->m_is_abstract, nullptr, 0, m_alignment, nullptr); @@ -1360,12 +1360,12 @@ class SymbolInstantiator : public ASR::BaseExprStmtDuplicatorbase.loc, substitute_type(tlist->m_type))); } - case (ASR::ttypeType::Struct) : { - ASR::Struct_t *s = ASR::down_cast(ttype); + case (ASR::ttypeType::StructType) : { + ASR::StructType_t *s = ASR::down_cast(ttype); std::string struct_name = ASRUtils::symbol_name(s->m_derived_type); if (symbol_subs.find(struct_name) != symbol_subs.end()) { ASR::symbol_t *sym = symbol_subs[struct_name]; - return ASRUtils::TYPE(ASR::make_Struct_t(al, ttype->base.loc, sym)); + return ASRUtils::TYPE(ASR::make_StructType_t(al, ttype->base.loc, sym)); } return ttype; } @@ -1444,10 +1444,10 @@ class BodyInstantiator : public ASR::BaseExprStmtDuplicator case (ASR::symbolType::Variable) : { break; } - case (ASR::symbolType::StructType) : { - LCOMPILERS_ASSERT(ASR::is_a(*new_sym)); - ASR::StructType_t* x = ASR::down_cast(sym); - instantiate_StructType(x); + case (ASR::symbolType::Struct) : { + LCOMPILERS_ASSERT(ASR::is_a(*new_sym)); + ASR::Struct_t* x = ASR::down_cast(sym); + instantiate_Struct(x); break; } case (ASR::symbolType::ClassProcedure) : { @@ -1522,8 +1522,8 @@ class BodyInstantiator : public ASR::BaseExprStmtDuplicator } } - void instantiate_StructType(ASR::StructType_t* x) { - ASR::StructType_t* new_s = ASR::down_cast(new_sym); + void instantiate_Struct(ASR::Struct_t* x) { + ASR::Struct_t* new_s = ASR::down_cast(new_sym); for (auto const &sym_pair: new_s->m_symtab->get_scope()) { ASR::symbol_t* new_sym_i = sym_pair.second; @@ -1780,12 +1780,12 @@ class BodyInstantiator : public ASR::BaseExprStmtDuplicator return ASRUtils::TYPE(ASR::make_List_t(al, ttype->base.loc, substitute_type(tlist->m_type))); } - case (ASR::ttypeType::Struct) : { - ASR::Struct_t *s = ASR::down_cast(ttype); + case (ASR::ttypeType::StructType) : { + ASR::StructType_t *s = ASR::down_cast(ttype); std::string struct_name = ASRUtils::symbol_name(s->m_derived_type); if (symbol_subs.find(struct_name) != symbol_subs.end()) { ASR::symbol_t *sym = symbol_subs[struct_name]; - ttype = ASRUtils::TYPE(ASR::make_Struct_t(al, s->base.base.loc, sym)); + ttype = ASRUtils::TYPE(ASR::make_StructType_t(al, s->base.base.loc, sym)); } return ttype; } diff --git a/src/libasr/pass/nested_vars.cpp b/src/libasr/pass/nested_vars.cpp index 51b7b4a23e..3d1bcdbf9a 100644 --- a/src/libasr/pass/nested_vars.cpp +++ b/src/libasr/pass/nested_vars.cpp @@ -286,8 +286,8 @@ class ReplaceNestedVisitor: public ASR::CallReplacerOnExpressionsVisitorm_type)); ASR::ttype_t* var_type_ = ASRUtils::type_get_past_array(var_type); - if( ASR::is_a(*var_type_) ) { - ASR::Struct_t* struct_t = ASR::down_cast(var_type_); + if( ASR::is_a(*var_type_) ) { + ASR::StructType_t* struct_t = ASR::down_cast(var_type_); if( current_scope->get_counter() != ASRUtils::symbol_parent_symtab( struct_t->m_derived_type)->get_counter() ) { ASR::symbol_t* m_derived_type = current_scope->get_symbol( @@ -306,7 +306,7 @@ class ReplaceNestedVisitor: public ASR::CallReplacerOnExpressionsVisitor(fn); current_scope->add_symbol(fn_name, m_derived_type); } - var_type_ = ASRUtils::TYPE(ASR::make_Struct_t(al, struct_t->base.base.loc, + var_type_ = ASRUtils::TYPE(ASR::make_StructType_t(al, struct_t->base.base.loc, m_derived_type)); if( ASR::is_a(*var_type) ) { ASR::Array_t* array_t = ASR::down_cast(var_type); diff --git a/src/libasr/pass/pass_utils.cpp b/src/libasr/pass/pass_utils.cpp index 94c5f5db48..7ad1307b15 100644 --- a/src/libasr/pass/pass_utils.cpp +++ b/src/libasr/pass/pass_utils.cpp @@ -92,13 +92,13 @@ namespace LCompilers { #define fix_struct_type_scope() array_ref_type = ASRUtils::type_get_past_array( \ ASRUtils::type_get_past_pointer( \ ASRUtils::type_get_past_allocatable(array_ref_type))); \ - if( current_scope && ASR::is_a(*array_ref_type) ) { \ - ASR::Struct_t* struct_t = ASR::down_cast(array_ref_type); \ + if( current_scope && ASR::is_a(*array_ref_type) ) { \ + ASR::StructType_t* struct_t = ASR::down_cast(array_ref_type); \ if( current_scope->get_counter() != ASRUtils::symbol_parent_symtab( \ struct_t->m_derived_type)->get_counter() ) { \ ASR::symbol_t* m_derived_type = current_scope->resolve_symbol( \ ASRUtils::symbol_name(struct_t->m_derived_type)); \ - ASR::ttype_t* struct_type = ASRUtils::TYPE(ASR::make_Struct_t(al, \ + ASR::ttype_t* struct_type = ASRUtils::TYPE(ASR::make_StructType_t(al, \ struct_t->base.base.loc, m_derived_type)); \ array_ref_type = struct_type; \ } \ @@ -681,7 +681,7 @@ namespace LCompilers { ASR::dimension_t* m_dims; int n_dims = ASRUtils::extract_dimensions_from_ttype(x_mv_type, m_dims); bool is_data_only_array = ASRUtils::is_fixed_size_array(m_dims, n_dims) && ASRUtils::get_asr_owner(arr_expr) && - ASR::is_a(*ASRUtils::get_asr_owner(arr_expr)); + ASR::is_a(*ASRUtils::get_asr_owner(arr_expr)); ASR::ttype_t* int32_type = ASRUtils::TYPE(ASR::make_Integer_t(al, arr_expr->base.loc, 4)); if (is_data_only_array) { const Location& loc = arr_expr->base.loc; diff --git a/src/libasr/pass/pass_utils.h b/src/libasr/pass/pass_utils.h index e5229e276a..e88563f72e 100644 --- a/src/libasr/pass/pass_utils.h +++ b/src/libasr/pass/pass_utils.h @@ -132,11 +132,11 @@ namespace LCompilers { ASR::ttype_t* return_type, ASR::expr_t* arr_item, ASR::stmt_t* stmt, int curr_idx); static inline bool is_aggregate_type(ASR::expr_t* var) { - return ASR::is_a(*ASRUtils::expr_type(var)); + return ASR::is_a(*ASRUtils::expr_type(var)); } static inline bool is_aggregate_or_array_type(ASR::expr_t* var) { - return (ASR::is_a(*ASRUtils::expr_type(var)) || + return (ASR::is_a(*ASRUtils::expr_type(var)) || ASRUtils::is_array(ASRUtils::expr_type(var)) || ASR::is_a(*ASRUtils::expr_type(var))); } @@ -218,12 +218,12 @@ namespace LCompilers { return arg; } - template - class PassVisitor: public ASR::ASRPassBaseWalkVisitor { + template + class PassVisitor: public ASR::ASRPassBaseWalkVisitor { private: - Struct& self() { return static_cast(*this); } + StructType& self() { return static_cast(*this); } public: @@ -333,19 +333,19 @@ namespace LCompilers { }; - template - class SkipOptimizationFunctionVisitor: public PassVisitor { + template + class SkipOptimizationFunctionVisitor: public PassVisitor { public: - SkipOptimizationFunctionVisitor(Allocator& al_): PassVisitor(al_, nullptr) { + SkipOptimizationFunctionVisitor(Allocator& al_): PassVisitor(al_, nullptr) { } void visit_Function(const ASR::Function_t &x) { if( ASRUtils::is_intrinsic_optimization(&x) ) { return ; } - PassUtils::PassVisitor::visit_Function(x); + PassUtils::PassVisitor::visit_Function(x); } }; @@ -548,8 +548,8 @@ namespace LCompilers { for( auto itr: x.m_symtab->get_scope() ) { ASR::ttype_t* type = ASRUtils::extract_type( ASRUtils::symbol_type(itr.second)); - if( ASR::is_a(*type) ) { - ASR::Struct_t* struct_t = ASR::down_cast(type); + if( ASR::is_a(*type) ) { + ASR::StructType_t* struct_t = ASR::down_cast(type); vec.push_back(al, ASRUtils::symbol_name(struct_t->m_derived_type)); } else if( ASR::is_a(*type) ) { ASR::Enum_t* enum_t = ASR::down_cast(type); @@ -560,7 +560,7 @@ namespace LCompilers { xx.n_dependencies = vec.size(); } - void visit_StructType(const ASR::StructType_t& x) { + void visit_Struct(const ASR::Struct_t& x) { visit_UserDefinedType(x); } @@ -572,7 +572,7 @@ namespace LCompilers { namespace ReplacerUtils { template - void replace_StructTypeConstructor(ASR::StructTypeConstructor_t* x, + void replace_StructConstructor(ASR::StructConstructor_t* x, T* replacer, bool inside_symtab, bool& remove_original_statement, Vec* result_vec, bool perform_cast=false, @@ -598,8 +598,8 @@ namespace LCompilers { } std::deque constructor_arg_syms; - ASR::Struct_t* dt_der = ASR::down_cast(x->m_type); - ASR::StructType_t* dt_dertype = ASR::down_cast( + ASR::StructType_t* dt_der = ASR::down_cast(x->m_type); + ASR::Struct_t* dt_dertype = ASR::down_cast( ASRUtils::symbol_get_past_external(dt_der->m_derived_type)); while( dt_dertype ) { for( int i = (int) dt_dertype->n_members - 1; i >= 0; i-- ) { @@ -610,8 +610,8 @@ namespace LCompilers { if( dt_dertype->m_parent != nullptr ) { ASR::symbol_t* dt_der_sym = ASRUtils::symbol_get_past_external( dt_dertype->m_parent); - LCOMPILERS_ASSERT(ASR::is_a(*dt_der_sym)); - dt_dertype = ASR::down_cast(dt_der_sym); + LCOMPILERS_ASSERT(ASR::is_a(*dt_der_sym)); + dt_dertype = ASR::down_cast(dt_der_sym); } else { dt_dertype = nullptr; } @@ -623,7 +623,7 @@ namespace LCompilers { continue ; } ASR::symbol_t* member = constructor_arg_syms[i]; - if( ASR::is_a(*x->m_args[i].m_value) ) { + if( ASR::is_a(*x->m_args[i].m_value) ) { ASR::expr_t* result_var_copy = replacer->result_var; ASR::symbol_t *v = nullptr; if (ASR::is_a(*result_var_copy)) { diff --git a/src/libasr/pass/print_struct_type.cpp b/src/libasr/pass/print_struct_type.cpp index fe95cc60e2..79b083628d 100644 --- a/src/libasr/pass/print_struct_type.cpp +++ b/src/libasr/pass/print_struct_type.cpp @@ -12,7 +12,7 @@ namespace LCompilers { using ASR::down_cast; using ASR::is_a; -class PrintStructTypeVisitor : public PassUtils::PassVisitor +class PrintStructVisitor : public PassUtils::PassVisitor { private: @@ -21,17 +21,17 @@ class PrintStructTypeVisitor : public PassUtils::PassVisitor& new_values) { if( struct_type_t->m_parent ) { ASR::symbol_t* parent = ASRUtils::symbol_get_past_external(struct_type_t->m_parent); - if( ASR::is_a(*parent) ) { - ASR::StructType_t* parent_struct_type_t = ASR::down_cast(parent); + if( ASR::is_a(*parent) ) { + ASR::Struct_t* parent_struct_type_t = ASR::down_cast(parent); print_struct_type(obj, parent_struct_type_t, new_values); } else { LCOMPILERS_ASSERT(false); @@ -51,7 +51,7 @@ class PrintStructTypeVisitor : public PassUtils::PassVisitor( \ + #define is_struct_type(value) if( ASR::is_a( \ *ASRUtils::expr_type(value)) ) \ bool is_struct_type_present = false; @@ -81,10 +81,10 @@ class PrintStructTypeVisitor : public PassUtils::PassVisitor(ASRUtils::expr_type(x_m_value)); + ASR::StructType_t* struct_t = ASR::down_cast(ASRUtils::expr_type(x_m_value)); ASR::symbol_t* struct_t_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); - if( ASR::is_a(*struct_t_sym) ) { - ASR::StructType_t* struct_type_t = ASR::down_cast(struct_t_sym); + if( ASR::is_a(*struct_t_sym) ) { + ASR::Struct_t* struct_type_t = ASR::down_cast(struct_t_sym); print_struct_type(x_m_value, struct_type_t, new_values); } else { LCOMPILERS_ASSERT(false); @@ -107,7 +107,7 @@ class PrintStructTypeVisitor : public PassUtils::PassVisitor - class StatementWalkVisitor : public PassUtils::PassVisitor + template + class StatementWalkVisitor : public PassUtils::PassVisitor { public: - StatementWalkVisitor(Allocator &al_) : PassUtils::PassVisitor(al_, nullptr) { + StatementWalkVisitor(Allocator &al_) : PassUtils::PassVisitor(al_, nullptr) { } void visit_WhileLoop(const ASR::WhileLoop_t &x) { // FIXME: this is a hack, we need to pass in a non-const `x`, // which requires to generate a TransformVisitor. ASR::WhileLoop_t &xx = const_cast(x); - PassUtils::PassVisitor::transform_stmts(xx.m_body, xx.n_body); + PassUtils::PassVisitor::transform_stmts(xx.m_body, xx.n_body); } void visit_DoLoop(const ASR::DoLoop_t &x) { // FIXME: this is a hack, we need to pass in a non-const `x`, // which requires to generate a TransformVisitor. ASR::DoLoop_t &xx = const_cast(x); - PassUtils::PassVisitor::transform_stmts(xx.m_body, xx.n_body); + PassUtils::PassVisitor::transform_stmts(xx.m_body, xx.n_body); } }; } // namespace ASR diff --git a/src/libasr/pass/unique_symbols.cpp b/src/libasr/pass/unique_symbols.cpp index fdccda31ec..806c5669b9 100644 --- a/src/libasr/pass/unique_symbols.cpp +++ b/src/libasr/pass/unique_symbols.cpp @@ -242,7 +242,7 @@ class SymbolRenameVisitor: public ASR::BaseWalkVisitor { } } - void visit_StructType(const ASR::StructType_t &x) { + void visit_Struct(const ASR::Struct_t &x) { visit_symbols_2(x); } @@ -444,7 +444,7 @@ class UniqueSymbolVisitor: public ASR::BaseWalkVisitor { current_scope = current_scope_copy; } - void visit_StructType(const ASR::StructType_t &x) { + void visit_Struct(const ASR::Struct_t &x) { update_symbols_2(x); } diff --git a/src/libasr/serialization.cpp b/src/libasr/serialization.cpp index 12967cda78..3b5148fc09 100644 --- a/src/libasr/serialization.cpp +++ b/src/libasr/serialization.cpp @@ -117,7 +117,7 @@ class ASRDeserializationVisitor : READ_SYMBOL_CASE(Function) READ_SYMBOL_CASE(GenericProcedure) READ_SYMBOL_CASE(ExternalSymbol) - READ_SYMBOL_CASE(StructType) + READ_SYMBOL_CASE(Struct) READ_SYMBOL_CASE(Variable) READ_SYMBOL_CASE(ClassProcedure) default : throw LCompilersException("Symbol type not supported"); @@ -142,7 +142,7 @@ class ASRDeserializationVisitor : INSERT_SYMBOL_CASE(Function) INSERT_SYMBOL_CASE(GenericProcedure) INSERT_SYMBOL_CASE(ExternalSymbol) - INSERT_SYMBOL_CASE(StructType) + INSERT_SYMBOL_CASE(Struct) INSERT_SYMBOL_CASE(Variable) INSERT_SYMBOL_CASE(ClassProcedure) default : throw LCompilersException("Symbol type not supported"); @@ -221,7 +221,7 @@ class FixParentSymtabVisitor : public BaseWalkVisitor current_symtab = parent_symtab; } - void visit_StructType(const StructType_t &x) { + void visit_Struct(const Struct_t &x) { SymbolTable *parent_symtab = current_symtab; current_symtab = x.m_symtab; x.m_symtab->parent = parent_symtab; @@ -357,8 +357,8 @@ class FixExternalSymbolsVisitor : public BaseWalkVisitor(*m_sym) ) { - StructType_t *m = down_cast(m_sym); + if( ASR::is_a(*m_sym) ) { + Struct_t *m = down_cast(m_sym); sym = m->m_symtab->find_scoped_symbol(original_name, x.n_scope_names, x.m_scope_names); } else if( ASR::is_a(*m_sym) ) { diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp index f7067e3e82..19aee99819 100644 --- a/src/lpython/semantics/python_ast_to_asr.cpp +++ b/src/lpython/semantics/python_ast_to_asr.cpp @@ -548,13 +548,13 @@ class CommonVisitor : public AST::BaseVisitor { } return ASRUtils::TYPE(ASR::make_Character_t(al, loc, t->m_kind, a_len, func_calls[0])); } - case ASR::ttypeType::Struct: { - ASR::Struct_t* struct_t_type = ASR::down_cast(return_type); + case ASR::ttypeType::StructType: { + ASR::StructType_t* struct_t_type = ASR::down_cast(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::StructType_t *st = ASR::down_cast(sym); + ASR::Struct_t *st = ASR::down_cast(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); @@ -570,7 +570,7 @@ class CommonVisitor : public AST::BaseVisitor { } else { sym = es_s; } - return ASRUtils::TYPE(ASR::make_Struct_t(al, loc, sym)); + return ASRUtils::TYPE(ASR::make_StructType_t(al, loc, sym)); } default: { return return_type; @@ -719,7 +719,7 @@ class CommonVisitor : public AST::BaseVisitor { return true; } - int64_t find_argument_position_from_name(ASR::StructType_t* orig_struct, std::string arg_name) { + 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 ) { @@ -732,7 +732,7 @@ class CommonVisitor : public AST::BaseVisitor { void visit_expr_list(AST::expr_t** pos_args, size_t n_pos_args, AST::keyword_t* kwargs, size_t n_kwargs, Vec& call_args_vec, - ASR::StructType_t* orig_struct, const Location &loc) { + ASR::Struct_t* orig_struct, const Location &loc) { LCOMPILERS_ASSERT(call_args_vec.reserve_called); // Fill the whole call_args_vec with nullptr @@ -821,8 +821,8 @@ class CommonVisitor : public AST::BaseVisitor { } else { ASR::symbol_t *der_sym = ASRUtils::symbol_get_past_external(s); if( der_sym ) { - if ( ASR::is_a(*der_sym) ) { - type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, s)); + if ( ASR::is_a(*der_sym) ) { + type = ASRUtils::TYPE(ASR::make_StructType_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(*der_sym) ) { type = ASRUtils::TYPE(ASR::make_Enum_t(al, loc, s)); @@ -944,9 +944,9 @@ class CommonVisitor : public AST::BaseVisitor { ); current_module_dependencies.push_back(al, m->m_name); return ASR::down_cast(fn); - } else if (ASR::is_a(*t)) { - ASR::StructType_t *st = ASR::down_cast(t); - // `st` is the StructType in a module. Now we construct + } else if (ASR::is_a(*t)) { + ASR::Struct_t *st = ASR::down_cast(t); + // `st` is the Struct in a module. Now we construct // an ExternalSymbol that points to it. Str name; name.from_str(al, new_sym_name); @@ -1040,7 +1040,7 @@ class CommonVisitor : public AST::BaseVisitor { 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 " + throw SemanticError("Only Subroutines, Functions, Struct, Variables and " "ExternalSymbol are currently supported in 'import'", loc); } LCOMPILERS_ASSERT(false); @@ -1274,23 +1274,23 @@ class CommonVisitor : public AST::BaseVisitor { return ASRUtils::make_SubroutineCall_t_util(al, loc, stemp, s_generic, args_new.p, args_new.size(), nullptr, nullptr, false, false); } - } else if(ASR::is_a(*s)) { - ASR::StructType_t* StructType = ASR::down_cast(s); + } else if(ASR::is_a(*s)) { + ASR::Struct_t* st = ASR::down_cast(s); if (n_kwargs > 0) { args.reserve(al, n_pos_args + n_kwargs); visit_expr_list(pos_args, n_pos_args, kwargs, n_kwargs, - args, StructType, loc); + args, st, loc); } - if (args.size() > 0 && args.size() > StructType->n_members) { - throw SemanticError("Struct constructor has more arguments than the number of struct members", + if (args.size() > 0 && args.size() > st->n_members) { + throw SemanticError("StructConstructor has more arguments than the number of struct members", loc); } for( size_t i = 0; i < args.size(); i++ ) { - std::string member_name = StructType->m_members[i]; + std::string member_name = st->m_members[i]; ASR::Variable_t* member_var = ASR::down_cast( - StructType->m_symtab->resolve_symbol(member_name)); + st->m_symtab->resolve_symbol(member_name)); ASR::expr_t* arg_new_i = args[i].m_value; cast_helper(member_var->m_type, arg_new_i, arg_new_i->base.loc); ASR::ttype_t* left_type = member_var->m_type; @@ -1309,11 +1309,11 @@ class CommonVisitor : public AST::BaseVisitor { } args.p[i].m_value = arg_new_i; } - for (size_t i = args.size(); i < StructType->n_members; i++) { - args.push_back(al, StructType->m_initializers[i]); + for (size_t i = args.size(); i < st->n_members; i++) { + args.push_back(al, st->m_initializers[i]); } - ASR::ttype_t* der_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, stemp)); - return ASR::make_StructTypeConstructor_t(al, loc, stemp, args.p, args.size(), der_type, nullptr); + ASR::ttype_t* der_type = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, stemp)); + return ASR::make_StructConstructor_t(al, loc, stemp, args.p, args.size(), der_type, nullptr); } else if( ASR::is_a(*s) ) { Vec args_new; args_new.reserve(al, args.size()); @@ -1882,8 +1882,8 @@ class CommonVisitor : public AST::BaseVisitor { throw SemanticError("'" + value + "' is not defined in the scope", attr_annotation->base.base.loc); } - LCOMPILERS_ASSERT(ASR::is_a(*t)); - ASR::StructType_t* struct_type = ASR::down_cast(t); + LCOMPILERS_ASSERT(ASR::is_a(*t)); + ASR::Struct_t* struct_type = ASR::down_cast(t); std::string struct_var_name = struct_type->m_name; std::string struct_member_name = attr_annotation->m_attr; ASR::symbol_t* struct_member = struct_type->m_symtab->resolve_symbol(struct_member_name); @@ -2730,10 +2730,10 @@ class CommonVisitor : public AST::BaseVisitor { ); throw SemanticAbort(); } - if (ASR::is_a(*asr_alloc_type)) { - ASR::symbol_t *sym = ASRUtils::symbol_get_past_external(ASR::down_cast(asr_alloc_type)->m_derived_type); - if (ASR::is_a(*sym)) { - ASR::StructType_t *st = ASR::down_cast(sym); + if (ASR::is_a(*asr_alloc_type)) { + ASR::symbol_t *sym = ASRUtils::symbol_get_past_external(ASR::down_cast(asr_alloc_type)->m_derived_type); + if (ASR::is_a(*sym)) { + ASR::Struct_t *st = ASR::down_cast(sym); if (st->m_abi != ASR::abiType::BindC) { diag.add(diag::Diagnostic( "The struct in c_p_pointer must be C interoperable", @@ -2858,7 +2858,7 @@ class CommonVisitor : public AST::BaseVisitor { handle_lambda_function_declaration(var_name, fn_type, x.m_value, x.base.base.loc); return; } - if( ASR::is_a(*type) && + if( ASR::is_a(*type) && wrap_derived_type_in_pointer ) { type = ASRUtils::TYPE(ASR::make_Pointer_t(al, type->base.loc, type)); } @@ -2883,7 +2883,7 @@ class CommonVisitor : public AST::BaseVisitor { if (x.m_value) { this->visit_expr(*x.m_value); } else { - if (ASR::is_a(*type)) { + if (ASR::is_a(*type)) { //`s` must be initialized with an instance of S throw SemanticError("`" + var_name + "` must be initialized with an instance of " + ASRUtils::type_to_str_python(type), x.base.base.loc); @@ -2995,9 +2995,9 @@ class CommonVisitor : public AST::BaseVisitor { } ASR::ttype_t* var_type = ASRUtils::type_get_past_pointer(ASRUtils::symbol_type(var_sym)); char* aggregate_type_name = nullptr; - if( ASR::is_a(*var_type) ) { + if( ASR::is_a(*var_type) ) { aggregate_type_name = ASRUtils::symbol_name( - ASR::down_cast(var_type)->m_derived_type); + ASR::down_cast(var_type)->m_derived_type); } else if( ASR::is_a(*var_type) ) { aggregate_type_name = ASRUtils::symbol_name( ASR::down_cast(var_type)->m_enum_type); @@ -3175,7 +3175,7 @@ class CommonVisitor : public AST::BaseVisitor { } visit_ClassMembers(x, member_names, struct_dependencies, member_init, false, class_abi); LCOMPILERS_ASSERT(member_init.size() == member_names.size()); - ASR::symbol_t* class_type = ASR::down_cast(ASR::make_StructType_t(al, + ASR::symbol_t* class_type = ASR::down_cast(ASR::make_Struct_t(al, x.base.base.loc, current_scope, x.m_name, struct_dependencies.p, struct_dependencies.size(), member_names.p, member_names.size(), @@ -3185,7 +3185,7 @@ class CommonVisitor : public AST::BaseVisitor { current_scope = parent_scope; if (current_scope->resolve_symbol(x_m_name)) { ASR::symbol_t* sym = current_scope->resolve_symbol(x_m_name); - ASR::StructType_t *st = ASR::down_cast(sym); + ASR::Struct_t *st = ASR::down_cast(sym); st->m_initializers = member_init.p; st->n_initializers = member_init.size(); } else { @@ -5785,10 +5785,10 @@ class BodyVisitor : public CommonVisitor { void visit_AttributeUtil(ASR::ttype_t* type, char* attr_char, ASR::expr_t *e, const Location& loc) { - if( ASR::is_a(*type) ) { - ASR::Struct_t* der = ASR::down_cast(type); + if( ASR::is_a(*type) ) { + ASR::StructType_t* der = ASR::down_cast(type); ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_derived_type); - ASR::StructType_t* der_type = ASR::down_cast(der_sym); + ASR::Struct_t* der_type = ASR::down_cast(der_sym); bool member_found = false; std::string member_name = attr_char; for( size_t i = 0; i < der_type->n_members && !member_found; i++ ) { @@ -5803,13 +5803,13 @@ class BodyVisitor : public CommonVisitor { LCOMPILERS_ASSERT(ASR::is_a(*member_sym)); ASR::Variable_t* member_var = ASR::down_cast(member_sym); ASR::ttype_t* member_var_type = member_var->m_type; - if( ASR::is_a(*member_var->m_type) ) { - ASR::Struct_t* member_var_struct_t = ASR::down_cast(member_var->m_type); + if( ASR::is_a(*member_var->m_type) ) { + ASR::StructType_t* member_var_struct_t = ASR::down_cast(member_var->m_type); if( !ASR::is_a(*member_var_struct_t->m_derived_type) ) { - ASR::StructType_t* struct_type = ASR::down_cast(member_var_struct_t->m_derived_type); + ASR::Struct_t* struct_type = ASR::down_cast(member_var_struct_t->m_derived_type); ASR::symbol_t* struct_type_asr_owner = ASRUtils::get_asr_owner(member_var_struct_t->m_derived_type); - if( struct_type_asr_owner && ASR::is_a(*struct_type_asr_owner) ) { - std::string struct_var_name = ASR::down_cast(struct_type_asr_owner)->m_name; + if( struct_type_asr_owner && ASR::is_a(*struct_type_asr_owner) ) { + std::string struct_var_name = ASR::down_cast(struct_type_asr_owner)->m_name; std::string struct_member_name = struct_type->m_name; std::string import_name = struct_var_name + "_" + struct_member_name; ASR::symbol_t* import_struct_member = current_scope->resolve_symbol(import_name); @@ -5831,7 +5831,7 @@ class BodyVisitor : public CommonVisitor { s2c(al, struct_member_name), ASR::accessType::Public)); current_scope->add_symbol(import_name, import_struct_member); } - member_var_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, import_struct_member)); + member_var_type = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, import_struct_member)); } } } @@ -5918,10 +5918,10 @@ class BodyVisitor : public CommonVisitor { throw SemanticError("'" + attr + "' is not implemented for Complex type", loc); } - } else if( ASR::is_a(*type) ) { - ASR::Struct_t* der = ASR::down_cast(type); + } else if( ASR::is_a(*type) ) { + ASR::StructType_t* der = ASR::down_cast(type); ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_derived_type); - ASR::StructType_t* der_type = ASR::down_cast(der_sym); + ASR::Struct_t* der_type = ASR::down_cast(der_sym); bool member_found = false; std::string member_name = attr_char; for( size_t i = 0; i < der_type->n_members && !member_found; i++ ) { @@ -5937,13 +5937,13 @@ class BodyVisitor : public CommonVisitor { LCOMPILERS_ASSERT(ASR::is_a(*member_sym)); ASR::Variable_t* member_var = ASR::down_cast(member_sym); ASR::ttype_t* member_var_type = member_var->m_type; - if( ASR::is_a(*member_var->m_type) ) { - ASR::Struct_t* member_var_struct_t = ASR::down_cast(member_var->m_type); + if( ASR::is_a(*member_var->m_type) ) { + ASR::StructType_t* member_var_struct_t = ASR::down_cast(member_var->m_type); if( !ASR::is_a(*member_var_struct_t->m_derived_type) ) { - ASR::StructType_t* struct_type = ASR::down_cast(member_var_struct_t->m_derived_type); + ASR::Struct_t* struct_type = ASR::down_cast(member_var_struct_t->m_derived_type); ASR::symbol_t* struct_type_asr_owner = ASRUtils::get_asr_owner(member_var_struct_t->m_derived_type); - if( struct_type_asr_owner && ASR::is_a(*struct_type_asr_owner) ) { - std::string struct_var_name = ASR::down_cast(struct_type_asr_owner)->m_name; + if( struct_type_asr_owner && ASR::is_a(*struct_type_asr_owner) ) { + std::string struct_var_name = ASR::down_cast(struct_type_asr_owner)->m_name; std::string struct_member_name = struct_type->m_name; std::string import_name = struct_var_name + "_" + struct_member_name; ASR::symbol_t* import_struct_member = current_scope->resolve_symbol(import_name); @@ -5965,7 +5965,7 @@ class BodyVisitor : public CommonVisitor { s2c(al, struct_member_name), ASR::accessType::Public)); current_scope->add_symbol(import_name, import_struct_member); } - member_var_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, import_struct_member)); + member_var_type = ASRUtils::TYPE(ASR::make_StructType_t(al, loc, import_struct_member)); } } } @@ -6067,8 +6067,8 @@ class BodyVisitor : public CommonVisitor { tmp = ASR::make_EnumValue_t(al, x.base.base.loc, enum_member_var, enum_t, enum_member_variable->m_type, ASRUtils::expr_value(enum_member_variable->m_symbolic_value)); - } else if (ASR::is_a(*t)) { - ASR::StructType_t* struct_type = ASR::down_cast(t); + } else if (ASR::is_a(*t)) { + ASR::Struct_t* struct_type = ASR::down_cast(t); ASR::symbol_t* struct_member = struct_type->m_symtab->resolve_symbol(std::string(x.m_attr)); if( !struct_member ) { throw SemanticError(std::string(x.m_attr) + " not present in " + @@ -7690,13 +7690,13 @@ we will have to use something else. st = import_from_module(al, m, current_scope, mod_name, call_name, call_name_store, loc); current_scope->add_symbol(call_name_store, st); - } else if( ASR::is_a(*st) ) { + } else if( ASR::is_a(*st) ) { st = get_struct_member(st, call_name, loc); } else if ( ASR::is_a(*st)) { ASR::Variable_t* var = ASR::down_cast(st); - if (ASR::is_a(*var->m_type)) { + if (ASR::is_a(*var->m_type)) { // call to struct member function - ASR::Struct_t* var_struct = ASR::down_cast(var->m_type); + ASR::StructType_t* var_struct = ASR::down_cast(var->m_type); st = get_struct_member(var_struct->m_derived_type, call_name, loc); } else { // this case when we have variable and attribute @@ -7851,13 +7851,13 @@ we will have to use something else. } ASR::symbol_t* get_struct_member(ASR::symbol_t* struct_type_sym, std::string &call_name, const Location &loc) { - ASR::StructType_t* struct_type = ASR::down_cast(struct_type_sym); + ASR::Struct_t* struct_type = ASR::down_cast(struct_type_sym); std::string struct_var_name = struct_type->m_name; std::string struct_member_name = call_name; ASR::symbol_t* struct_member = struct_type->m_symtab->resolve_symbol(struct_member_name); ASR::symbol_t* struct_mem_asr_owner = ASRUtils::get_asr_owner(struct_member); if( !struct_member || !struct_mem_asr_owner || - !ASR::is_a(*struct_mem_asr_owner) ) { + !ASR::is_a(*struct_mem_asr_owner) ) { throw SemanticError(struct_member_name + " not present in " + struct_var_name + " dataclass", loc); } @@ -8299,7 +8299,7 @@ we will have to use something else. ASR::Var_t* arg_Var = ASR::down_cast(arg); ASR::symbol_t* arg_Var_m_v = ASRUtils::symbol_get_past_external(arg_Var->m_v); if( ASR::is_a(*arg_Var_m_v) ) { - // TODO: Import the underlying struct if arg_type is of Struct type + // TODO: Import the underlying struct if arg_type is of StructType type // Ideally if a variable of struct type is being imported then its underlying type // should also be imported automatically. However, the naming of the // underlying struct type might lead to collisions, so importing the type diff --git a/tests/reference/asr-intent_01-66824bc.json b/tests/reference/asr-intent_01-66824bc.json index c981754321..433f0e2ca0 100644 --- a/tests/reference/asr-intent_01-66824bc.json +++ b/tests/reference/asr-intent_01-66824bc.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-intent_01-66824bc.stdout", - "stdout_hash": "415fb57ee7c986fc49e7c0801edae4e37d6ea06143d27a998c50ab5c", + "stdout_hash": "38b4d1ece76c889c88eefaa5555a6dc36a8af86de4aadd829c112e80", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-intent_01-66824bc.stdout b/tests/reference/asr-intent_01-66824bc.stdout index d668611200..7aca398930 100644 --- a/tests/reference/asr-intent_01-66824bc.stdout +++ b/tests/reference/asr-intent_01-66824bc.stdout @@ -8,7 +8,7 @@ 2 { Foo: - (StructType + (Struct (SymbolTable 3 { @@ -55,7 +55,7 @@ () Default (Array - (Struct + (StructType 2 Foo ) [((IntegerConstant 0 (Integer 4)) @@ -131,7 +131,7 @@ ) ) (Array - (Struct + (StructType 2 Foo ) [((IntegerConstant 0 (Integer 4)) diff --git a/tests/reference/asr-structs_01-66dc2c9.json b/tests/reference/asr-structs_01-66dc2c9.json index ab164948f8..ffb89bee77 100644 --- a/tests/reference/asr-structs_01-66dc2c9.json +++ b/tests/reference/asr-structs_01-66dc2c9.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_01-66dc2c9.stdout", - "stdout_hash": "5a32fdd6e6d78976f4d3effbdf4ab79c614eb664a4fd92967ff5d7d7", + "stdout_hash": "ea461fd5fd7cbed415b1c4f879f266ee64487c3545e6469091eefaa6", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_01-66dc2c9.stdout b/tests/reference/asr-structs_01-66dc2c9.stdout index afebbfd171..12475b9163 100644 --- a/tests/reference/asr-structs_01-66dc2c9.stdout +++ b/tests/reference/asr-structs_01-66dc2c9.stdout @@ -8,7 +8,7 @@ 2 { S: - (StructType + (Struct (SymbolTable 3 { @@ -108,7 +108,7 @@ () () Default - (Struct + (StructType 2 S ) () @@ -137,11 +137,11 @@ [] [(Assignment (Var 4 s) - (StructTypeConstructor + (StructConstructor 2 S [((IntegerConstant 2 (Integer 4))) (())] - (Struct + (StructType 2 S ) () diff --git a/tests/reference/asr-structs_01-be14d49.json b/tests/reference/asr-structs_01-be14d49.json index f149ce9e6e..fb6b14fc7d 100644 --- a/tests/reference/asr-structs_01-be14d49.json +++ b/tests/reference/asr-structs_01-be14d49.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_01-be14d49.stdout", - "stdout_hash": "6ff17e00a05b231e19396a82ff1a25538d74f39f4df7ccc44abf592c", + "stdout_hash": "9bfbbca1021052ba2e89a60c105899a6957f0adc9b1e271f33f81522", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_01-be14d49.stdout b/tests/reference/asr-structs_01-be14d49.stdout index e96c8d99c9..f32b9dfce5 100644 --- a/tests/reference/asr-structs_01-be14d49.stdout +++ b/tests/reference/asr-structs_01-be14d49.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 3 { @@ -108,7 +108,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -120,7 +120,7 @@ }) change_struct (FunctionType - [(Struct + [(StructType 2 A )] () @@ -207,7 +207,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -219,7 +219,7 @@ }) f (FunctionType - [(Struct + [(StructType 2 A )] () @@ -276,7 +276,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -306,7 +306,7 @@ [] [(Assignment (Var 6 x) - (StructTypeConstructor + (StructConstructor 2 A [((Cast (RealConstant @@ -321,7 +321,7 @@ ) )) ((IntegerConstant 3 (Integer 4)))] - (Struct + (StructType 2 A ) () diff --git a/tests/reference/asr-structs_02-2ab459a.json b/tests/reference/asr-structs_02-2ab459a.json index 298b5bc8a2..fcb607cfe5 100644 --- a/tests/reference/asr-structs_02-2ab459a.json +++ b/tests/reference/asr-structs_02-2ab459a.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_02-2ab459a.stdout", - "stdout_hash": "cc9088a5c112c3dd9820ddfb3695cc301e46d853c4f4634fcdb457b6", + "stdout_hash": "e910877f218afa129f1152ab8ce74e1c0872f2473bdb761d290b057f", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_02-2ab459a.stdout b/tests/reference/asr-structs_02-2ab459a.stdout index 00933ce63c..1f77addd15 100644 --- a/tests/reference/asr-structs_02-2ab459a.stdout +++ b/tests/reference/asr-structs_02-2ab459a.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 3 { @@ -124,7 +124,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -143,7 +143,7 @@ () Default (Pointer - (Struct + (StructType 2 A ) ) @@ -205,7 +205,7 @@ [(Var 4 a)] [(Assignment (Var 4 a1) - (StructTypeConstructor + (StructConstructor 2 A [((IntegerConstant 3 (Integer 4))) ((Cast @@ -220,7 +220,7 @@ (Real 4) ) ))] - (Struct + (StructType 2 A ) () @@ -232,7 +232,7 @@ (GetPointer (Var 4 a1) (Pointer - (Struct + (StructType 2 A ) ) @@ -245,7 +245,7 @@ (GetPointer (Var 4 a1) (Pointer - (Struct + (StructType 2 A ) ) diff --git a/tests/reference/asr-structs_03-0cef911.json b/tests/reference/asr-structs_03-0cef911.json index 4cff33ed98..98f5559970 100644 --- a/tests/reference/asr-structs_03-0cef911.json +++ b/tests/reference/asr-structs_03-0cef911.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_03-0cef911.stdout", - "stdout_hash": "86f4e5e4f8a98068919cc24f5e1add31777cbf511dcc6164587c58e3", + "stdout_hash": "f47b680d013f3ae57b3c7376d3d74527a0523942d81b577a7b6f0d90", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_03-0cef911.stdout b/tests/reference/asr-structs_03-0cef911.stdout index 5f268f4dde..56733602b4 100644 --- a/tests/reference/asr-structs_03-0cef911.stdout +++ b/tests/reference/asr-structs_03-0cef911.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 3 { @@ -109,7 +109,7 @@ () Default (Pointer - (Struct + (StructType 2 A ) ) @@ -123,7 +123,7 @@ f (FunctionType [(Pointer - (Struct + (StructType 2 A ) )] @@ -181,7 +181,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -200,7 +200,7 @@ () Default (Pointer - (Struct + (StructType 2 A ) ) @@ -230,7 +230,7 @@ [] [(Assignment (Var 5 x) - (StructTypeConstructor + (StructConstructor 2 A [((IntegerConstant 3 (Integer 4))) ((Cast @@ -245,7 +245,7 @@ (Real 4) ) ))] - (Struct + (StructType 2 A ) () @@ -257,7 +257,7 @@ (GetPointer (Var 5 x) (Pointer - (Struct + (StructType 2 A ) ) diff --git a/tests/reference/asr-structs_04-387747b.json b/tests/reference/asr-structs_04-387747b.json index d0f8cbec18..833fc5d2dc 100644 --- a/tests/reference/asr-structs_04-387747b.json +++ b/tests/reference/asr-structs_04-387747b.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_04-387747b.stdout", - "stdout_hash": "27f6a0c804ed3cea5368c4bec54cb4ea35c60215f354d0d91bc24e89", + "stdout_hash": "e53b9fa00b0c80ca7642803f56790172d7f512f12ce00c290c9796d2", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_04-387747b.stdout b/tests/reference/asr-structs_04-387747b.stdout index 32225f2ccf..4a28d6f0b0 100644 --- a/tests/reference/asr-structs_04-387747b.stdout +++ b/tests/reference/asr-structs_04-387747b.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 3 { @@ -59,7 +59,7 @@ () ), B: - (StructType + (Struct (SymbolTable 4 { @@ -72,7 +72,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -107,7 +107,7 @@ .false. .false. [(()) - ((StructTypeConstructor + ((StructConstructor 2 A [((Cast (RealConstant @@ -122,7 +122,7 @@ ) )) ((IntegerConstant 0 (Integer 4)))] - (Struct + (StructType 2 A ) () @@ -180,7 +180,7 @@ () () Default - (Struct + (StructType 2 B ) () @@ -192,7 +192,7 @@ }) f (FunctionType - [(Struct + [(StructType 2 B )] () @@ -220,7 +220,7 @@ (StructInstanceMember (Var 5 b) 4 a - (Struct + (StructType 2 A ) () @@ -233,7 +233,7 @@ (StructInstanceMember (Var 5 b) 4 a - (Struct + (StructType 2 A ) () @@ -266,7 +266,7 @@ (StructInstanceMember (Var 5 b) 4 a - (Struct + (StructType 2 A ) () @@ -289,7 +289,7 @@ (StructInstanceMember (Var 5 b) 4 a - (Struct + (StructType 2 A ) () @@ -332,7 +332,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -350,7 +350,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -368,7 +368,7 @@ () () Default - (Struct + (StructType 2 B ) () @@ -397,7 +397,7 @@ [] [(Assignment (Var 6 a1) - (StructTypeConstructor + (StructConstructor 2 A [((Cast (RealConstant @@ -412,7 +412,7 @@ ) )) ((IntegerConstant 1 (Integer 4)))] - (Struct + (StructType 2 A ) () @@ -421,7 +421,7 @@ ) (Assignment (Var 6 a2) - (StructTypeConstructor + (StructConstructor 2 A [((Cast (RealConstant @@ -436,7 +436,7 @@ ) )) ((IntegerConstant 2 (Integer 4)))] - (Struct + (StructType 2 A ) () @@ -445,11 +445,11 @@ ) (Assignment (Var 6 b) - (StructTypeConstructor + (StructConstructor 2 B [((IntegerConstant 1 (Integer 4))) ((Var 6 a1))] - (Struct + (StructType 2 B ) () @@ -460,7 +460,7 @@ (StructInstanceMember (Var 6 b) 4 a - (Struct + (StructType 2 A ) () @@ -483,7 +483,7 @@ (StructInstanceMember (Var 6 b) 4 a - (Struct + (StructType 2 A ) () @@ -500,7 +500,7 @@ (StructInstanceMember (Var 6 b) 4 a - (Struct + (StructType 2 A ) () diff --git a/tests/reference/asr-structs_05-fa98307.json b/tests/reference/asr-structs_05-fa98307.json index cc000e12a0..a7095206b3 100644 --- a/tests/reference/asr-structs_05-fa98307.json +++ b/tests/reference/asr-structs_05-fa98307.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_05-fa98307.stdout", - "stdout_hash": "46a6d4fc967a5081b9d2df3936f9a3696cc8383bd140ee0cb37c5e75", + "stdout_hash": "c63ee21559df1aebb160c48602c620f09fcbe66d78bbe27dbc26409f", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_05-fa98307.stdout b/tests/reference/asr-structs_05-fa98307.stdout index 1ef54ab37e..dcf4c533e2 100644 --- a/tests/reference/asr-structs_05-fa98307.stdout +++ b/tests/reference/asr-structs_05-fa98307.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 226 { @@ -199,7 +199,7 @@ () Default (Array - (Struct + (StructType 2 A ) [((IntegerConstant 0 (Integer 4)) @@ -237,7 +237,7 @@ (ArrayConstructor [] (Array - (Struct + (StructType 2 A ) [((IntegerConstant 0 (Integer 4)) @@ -255,13 +255,13 @@ [(() (IntegerConstant 0 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor () ) - (StructTypeConstructor + (StructConstructor 2 A [((RealConstant 1.100000 @@ -302,7 +302,7 @@ .true. (Logical 4) ))] - (Struct + (StructType 2 A ) () @@ -315,13 +315,13 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor () ) - (StructTypeConstructor + (StructConstructor 2 A [((RealConstant 2.200000 @@ -362,7 +362,7 @@ .true. (Logical 4) ))] - (Struct + (StructType 2 A ) () @@ -377,7 +377,7 @@ FixedSizeArray DescriptorArray (Array - (Struct + (StructType 2 A ) [((IntegerConstant 0 (Integer 4)) @@ -406,7 +406,7 @@ [(() (IntegerConstant 0 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -422,7 +422,7 @@ FixedSizeArray DescriptorArray (Array - (Struct + (StructType 2 A ) [((IntegerConstant 0 (Integer 4)) @@ -441,7 +441,7 @@ FixedSizeArray DescriptorArray (Array - (Struct + (StructType 2 A ) [((IntegerConstant 0 (Integer 4)) @@ -482,7 +482,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -494,7 +494,7 @@ }) update_1 (FunctionType - [(Struct + [(StructType 2 A )] () @@ -621,7 +621,7 @@ () Default (Array - (Struct + (StructType 2 A ) [(() @@ -638,7 +638,7 @@ update_2 (FunctionType [(Array - (Struct + (StructType 2 A ) [(() @@ -666,7 +666,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -686,7 +686,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -709,7 +709,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -734,7 +734,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -765,7 +765,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -790,7 +790,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -845,7 +845,7 @@ () Default (Array - (Struct + (StructType 2 A ) [(() @@ -867,7 +867,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -885,7 +885,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -962,7 +962,7 @@ verify (FunctionType [(Array - (Struct + (StructType 2 A ) [(() @@ -1006,7 +1006,7 @@ [(() (IntegerConstant 0 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor @@ -1221,7 +1221,7 @@ [(() (IntegerConstant 1 (Integer 4)) ())] - (Struct + (StructType 2 A ) RowMajor diff --git a/tests/reference/asr-structs_06-6e14537.json b/tests/reference/asr-structs_06-6e14537.json index 7ef7f9dd33..c20da8c4ab 100644 --- a/tests/reference/asr-structs_06-6e14537.json +++ b/tests/reference/asr-structs_06-6e14537.json @@ -8,6 +8,6 @@ "stdout": null, "stdout_hash": null, "stderr": "asr-structs_06-6e14537.stderr", - "stderr_hash": "8e0da9c7e84854ce3d6ad79066a9fbb33d82c9fcde3af2a7baeccec8", + "stderr_hash": "5e62a4e3dd0e816101d62ea1ec4817d9f1d376fb892c5191bd1e05f2", "returncode": 2 } \ No newline at end of file diff --git a/tests/reference/asr-structs_06-6e14537.stderr b/tests/reference/asr-structs_06-6e14537.stderr index 55d07bfb5e..a008d1b14f 100644 --- a/tests/reference/asr-structs_06-6e14537.stderr +++ b/tests/reference/asr-structs_06-6e14537.stderr @@ -1,4 +1,4 @@ -semantic error: Struct constructor has more arguments than the number of struct members +semantic error: StructConstructor has more arguments than the number of struct members --> tests/errors/structs_06.py:9:12 | 9 | s: S = S(2, 3, 4, 5) diff --git a/tests/reference/asr-structs_08-fa4dbf0.json b/tests/reference/asr-structs_08-fa4dbf0.json index 8f133e95a8..aa7ca81561 100644 --- a/tests/reference/asr-structs_08-fa4dbf0.json +++ b/tests/reference/asr-structs_08-fa4dbf0.json @@ -8,6 +8,6 @@ "stdout": null, "stdout_hash": null, "stderr": "asr-structs_08-fa4dbf0.stderr", - "stderr_hash": "cf488d893463c941c43080cebb56591bd17c5bed4cb7acd97353d59a", + "stderr_hash": "4353228fc05a0dfc3b833bd0340339e6c3c751a17222efb5fd7702a9", "returncode": 2 } \ No newline at end of file diff --git a/tests/reference/asr-structs_08-fa4dbf0.stderr b/tests/reference/asr-structs_08-fa4dbf0.stderr index 89af7c314c..2ddbd526d9 100644 --- a/tests/reference/asr-structs_08-fa4dbf0.stderr +++ b/tests/reference/asr-structs_08-fa4dbf0.stderr @@ -1,4 +1,4 @@ -semantic error: Struct constructor has more arguments than the number of struct members +semantic error: StructConstructor has more arguments than the number of struct members --> tests/errors/structs_08.py:13:29 | 13 | test_dude3 : StringIO = StringIO(integer_asr, 3, 5, 2) diff --git a/tests/reference/asr-structs_16-44de89a.json b/tests/reference/asr-structs_16-44de89a.json index 2710b9ad8a..1b70c72c0c 100644 --- a/tests/reference/asr-structs_16-44de89a.json +++ b/tests/reference/asr-structs_16-44de89a.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_16-44de89a.stdout", - "stdout_hash": "65cfcaf1a3de5bfe7720be9983c0a9ad22d877701f1375eead4ca4b1", + "stdout_hash": "256933d5fe98d3dad16d4fdeee012bcd5f01255ffd4f39d46151640a", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_16-44de89a.stdout b/tests/reference/asr-structs_16-44de89a.stdout index b98dbfb8e1..fe1c6a6270 100644 --- a/tests/reference/asr-structs_16-44de89a.stdout +++ b/tests/reference/asr-structs_16-44de89a.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 3 { @@ -168,7 +168,7 @@ () () Default - (Struct + (StructType 2 A ) () @@ -237,11 +237,11 @@ ) (Assignment (Var 5 ad) - (StructTypeConstructor + (StructConstructor 2 A [((Var 5 bd)) ((IntegerConstant 2 (Integer 4)))] - (Struct + (StructType 2 A ) () diff --git a/tests/reference/pass_class_constructor-structs_16-5e3508f.json b/tests/reference/pass_class_constructor-structs_16-5e3508f.json index 8204d2a621..1e9c2d47b1 100644 --- a/tests/reference/pass_class_constructor-structs_16-5e3508f.json +++ b/tests/reference/pass_class_constructor-structs_16-5e3508f.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "pass_class_constructor-structs_16-5e3508f.stdout", - "stdout_hash": "b2d0bddf9e8ba1877d428e44cb6bc2a32bb7d2c9db18a20d649dd7cf", + "stdout_hash": "7b07da67a935f00f37dc4f491778a540221af6fd57a0c1ebe2419b14", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/pass_class_constructor-structs_16-5e3508f.stdout b/tests/reference/pass_class_constructor-structs_16-5e3508f.stdout index 7ab18fc44d..8127cdb92a 100644 --- a/tests/reference/pass_class_constructor-structs_16-5e3508f.stdout +++ b/tests/reference/pass_class_constructor-structs_16-5e3508f.stdout @@ -8,7 +8,7 @@ 2 { A: - (StructType + (Struct (SymbolTable 3 { @@ -188,7 +188,7 @@ () () Default - (Struct + (StructType 2 A ) ()