Merge pull request #2079 from czgdp1807/phys_types

Implement physical types for arrays

Author: czgdp1807

integration_tests/test_dict_increment.py

@@ -22,21 +22,21 @@ def test_dict_increment():
         d_int_int[1] += i1
         i2 += i1
         assert d_int_int[1] == i2
-    
+
     i2 = 10
     d_int_int = {0: 0, 1: 0}
     for i1 in range(i2):
         d_int_int[i1 % 2] += 1
     assert d_int_int[0] == d_int_int[1]
     assert d_int_int[0] == i2 // 2
-    
+
     j1 = 2.0
     d_int_float = {2: j1}
     while j1 < 4.0:
         d_int_float[2] += 0.1
         j1 += 0.1
         assert d_int_float[2] == j1
-    
+
     j1 = 0.0
     j2 = 0.0
     d_bool_float = {True: 0.0, False: 0.0}
@@ -63,4 +63,4 @@ def test_dict_increment():
         s1 += str(i1)
         assert d_int_str[-1] == s1
 
-test_dict_increment()
+test_dict_increment()

src/libasr/ASR.asdl

@@ -322,7 +322,22 @@ expr
     | OverloadedCompare(expr left, cmpop op, expr right, ttype type, expr? value, expr overloaded)
     | OverloadedBinOp(expr left, binop op, expr right, ttype type, expr? value, expr overloaded)
     | OverloadedUnaryMinus(expr arg, ttype type, expr? value, expr overloaded)
+    -- This Cast changes the value (the bits) of the `arg`:
     | Cast(expr arg, cast_kind kind, ttype type, expr? value)
+    -- This ArrayPhysicalCast we only change the physical type, the logical type does not change
+    -- Note: the "new" physical type here will also be part of the "type" member
+    -- This allow to represent any combination, but we'll only support a few, at least we need:
+    -- Maybe it's easier to add an enumeration here:
+    -- Descriptor -> Pointer
+    -- Pointer -> Descriptor
+
+    -- CompileTimeFixedSizeArray -> Pointer
+    -- CompileTimeFixedSizeArray -> Descriptor
+    -- Descriptor -> NumPy
+    -- NumPy -> Descriptor
+    -- ISODescriptor -> Descriptor
+    -- Descriptor -> ISODescriptor
+    | ArrayPhysicalCast(expr arg, array_physical_type old, array_physical_type new, ttype type, expr? value)
     | ComplexRe(expr arg, ttype type, expr? value)
     | ComplexIm(expr arg, ttype type, expr? value)
     | DictItem(expr a, expr key, expr? default, ttype type, expr? value)
@@ -387,13 +402,19 @@ ttype
     | CPtr()
     | SymbolicExpression()
     | TypeParameter(identifier param)
-    | Array(ttype type, dimension* dims)
+    | Array(ttype type, dimension* dims, array_physical_type physical_type)
     | FunctionType(ttype* arg_types, ttype? return_var_type,
         abi abi, deftype deftype, string? bindc_name, bool elemental,
         bool pure, bool module, bool inline, bool static, ttype* type_params,
         symbol* restrictions, bool is_restriction)
 
-restriction_arg = RestrictionArg(identifier restriction_name, symbol restriction_func)
+-- TODO: prefix the enumerators here, improve the names
+array_physical_type
+    = DescriptorArray
+    | PointerToDataArray
+    | FixedSizeArray
+    | NumPyArray
+    | ISODescriptorArray
 
 binop = Add | Sub | Mul | Div | Pow | BitAnd | BitOr | BitXor | BitLShift | BitRShift
 

src/libasr/asr_utils.cpp

@@ -341,12 +341,8 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc,
     } else {
         LCOMPILERS_ASSERT(ASR::is_a<ASR::Variable_t>(*member));
         ASR::Variable_t* member_variable = ASR::down_cast<ASR::Variable_t>(member);
-        ASR::ttype_t* member_type = ASRUtils::type_get_past_allocatable(member_variable->m_type);
-        bool is_pointer = false;
-        if (ASRUtils::is_pointer(member_type)) {
-            is_pointer = true;
-            member_type = ASR::down_cast<ASR::Pointer_t>(member_type)->m_type;
-        }
+        ASR::ttype_t* member_type = ASRUtils::type_get_past_pointer(
+            ASRUtils::type_get_past_allocatable(member_variable->m_type));
         ASR::ttype_t* member_type_ = ASRUtils::type_get_past_array(member_type);
         ASR::dimension_t* m_dims = nullptr;
         size_t n_dims = ASRUtils::extract_dimensions_from_ttype(member_type, m_dims);
@@ -406,19 +402,20 @@ ASR::asr_t* getStructInstanceMember_t(Allocator& al, const Location& loc,
                 } else if(ASR::is_a<ASR::ExternalSymbol_t>(*der_type_sym)) {
                     member_type_ = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, der_type_sym));
                 }
-                member_type = member_type_;
-                if( n_dims > 0 ) {
-                    member_type = ASRUtils::make_Array_t_util(al, loc,
-                        member_type_, m_dims, n_dims);
-                }
+                member_type = ASRUtils::make_Array_t_util(al, loc,
+                    member_type_, m_dims, n_dims);
                 break;
             }
             default :
                 break;
         }
-        if (is_pointer) {
-            member_type = ASRUtils::TYPE(ASR::make_Pointer_t(al, loc,
-                ASRUtils::type_get_past_allocatable(member_type)));
+
+        if( ASR::is_a<ASR::Allocatable_t>(*member_variable->m_type) ) {
+            member_type = ASRUtils::TYPE(ASR::make_Allocatable_t(al,
+            member_variable->base.base.loc, member_type));
+        } else if( ASR::is_a<ASR::Pointer_t>(*member_variable->m_type) ) {
+            member_type = ASRUtils::TYPE(ASR::make_Pointer_t(al,
+            member_variable->base.base.loc, member_type));
         }
         ASR::symbol_t* member_ext = ASRUtils::import_struct_instance_member(al, member, current_scope, member_type);
         ASR::expr_t* value = nullptr;
@@ -537,7 +534,7 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right,
                             current_function_dependencies.push_back(al, s2c(al, matched_func_name));
                             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
                             ASRUtils::set_absent_optional_arguments_to_null(a_args, func, al);
-                            asr = ASR::make_FunctionCall_t(al, loc, a_name, sym,
+                            asr = ASRUtils::make_FunctionCall_t_util(al, loc, a_name, sym,
                                                             a_args.p, 2,
                                                             return_type,
                                                             nullptr, nullptr);
@@ -612,14 +609,15 @@ void process_overloaded_unary_minus_function(ASR::symbol_t* proc, ASR::expr_t* o
                     return_type = ASRUtils::TYPE(ASR::make_Struct_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);
+                        return_type = ASRUtils::make_Array_t_util(
+                            al, loc, return_type, m_dims, n_dims);
                     }
                 }
             }
             current_function_dependencies.push_back(al, s2c(al, matched_func_name));
             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
             ASRUtils::set_absent_optional_arguments_to_null(a_args, func, al);
-            asr = ASR::make_FunctionCall_t(al, loc, a_name, proc,
+            asr = ASRUtils::make_FunctionCall_t_util(al, loc, a_name, proc,
                                             a_args.p, 1,
                                             return_type,
                                             nullptr, nullptr);
@@ -790,7 +788,7 @@ void process_overloaded_assignment_function(ASR::symbol_t* proc, ASR::expr_t* ta
             current_function_dependencies.push_back(al, s2c(al, matched_subrout_name));
             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
             ASRUtils::set_absent_optional_arguments_to_null(a_args, subrout, al);
-            asr = ASR::make_SubroutineCall_t(al, loc, a_name, sym,
+            asr = ASRUtils::make_SubroutineCall_t_util(al, loc, a_name, sym,
                                             a_args.p, 2, nullptr);
         }
     }
@@ -930,7 +928,7 @@ bool use_overloaded(ASR::expr_t* left, ASR::expr_t* right,
                             current_function_dependencies.push_back(al, s2c(al, matched_func_name));
                             ASRUtils::insert_module_dependency(a_name, al, current_module_dependencies);
                             ASRUtils::set_absent_optional_arguments_to_null(a_args, func, al);
-                            asr = ASR::make_FunctionCall_t(al, loc, a_name, sym,
+                            asr = ASRUtils::make_FunctionCall_t_util(al, loc, a_name, sym,
                                                             a_args.p, 2,
                                                             return_type,
                                                             nullptr, nullptr);
@@ -1129,14 +1127,14 @@ ASR::asr_t* symbol_resolve_external_generic_procedure_without_eval(
         if( func ) {
             ASRUtils::set_absent_optional_arguments_to_null(args, func, al);
         }
-        return ASR::make_SubroutineCall_t(al, loc, final_sym,
+        return ASRUtils::make_SubroutineCall_t_util(al, loc, final_sym,
                                         v, args.p, args.size(),
                                         nullptr);
     } else {
         if( func ) {
             ASRUtils::set_absent_optional_arguments_to_null(args, func, al);
         }
-        return ASR::make_FunctionCall_t(al, loc, final_sym,
+        return ASRUtils::make_FunctionCall_t_util(al, loc, final_sym,
                                         v, args.p, args.size(),
                                         return_type,
                                         nullptr, nullptr);