Merge pull request #1238 from czgdp1807/arr_structs

czgdp1807 · web-flow · commit ec3b0d2bca52 · 2022-10-30T20:58:01.000+05:30
Support arrays inside structs
diff --git a/integration_tests/CMakeLists.txt b/integration_tests/CMakeLists.txt
@@ -265,6 +265,7 @@ RUN(NAME structs_07          LABELS llvm c
         EXTRAFILES structs_07b.c)
 RUN(NAME structs_08          LABELS cpython llvm c)
 RUN(NAME structs_09          LABELS cpython llvm c)
+RUN(NAME structs_10          LABELS cpython llvm c)
 RUN(NAME sizeof_01          LABELS llvm c
         EXTRAFILES sizeof_01b.c)
 RUN(NAME enum_01             LABELS cpython llvm c)
diff --git a/integration_tests/structs_10.py b/integration_tests/structs_10.py
@@ -0,0 +1,32 @@
+from ltypes import i32, f64, dataclass
+from numpy import empty, float64
+
+@dataclass
+class MatVec:
+    mat: f64[2, 2]
+    vec: f64[2]
+
+def rotate(mat_vec: MatVec) -> f64[2]:
+    rotated_vec: f64[2] = empty(2, dtype=float64)
+    rotated_vec[0] = mat_vec.mat[0, 0] * mat_vec.vec[0] + mat_vec.mat[0, 1] * mat_vec.vec[1]
+    rotated_vec[1] = mat_vec.mat[1, 0] * mat_vec.vec[0] + mat_vec.mat[1, 1] * mat_vec.vec[1]
+    return rotated_vec
+
+def test_rotate_by_90():
+    mat: f64[2, 2] = empty((2, 2), dtype=float64)
+    vec: f64[2] = empty(2, dtype=float64)
+    mat[0, 0] = 0.0
+    mat[0, 1] = -1.0
+    mat[1, 0] = 1.0
+    mat[1, 1] = 0.0
+    vec[0] = 1.0
+    vec[1] = 0.0
+    mat_vec: MatVec = MatVec(mat, vec)
+    print(mat_vec.mat[0, 0], mat_vec.mat[0, 1], mat_vec.mat[1, 0], mat_vec.mat[1, 1])
+    print(mat_vec.vec[0], mat_vec.vec[1])
+    rotated_vec: f64[2] = rotate(mat_vec)
+    print(rotated_vec[0], rotated_vec[1])
+    assert abs(rotated_vec[0] - 0.0) <= 1e-12
+    assert abs(rotated_vec[1] - 1.0) <= 1e-12
+
+test_rotate_by_90()
diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h
@@ -726,40 +726,50 @@ static inline void encode_dimensions(size_t n_dims, std::string& res,
 }
 
 static inline std::string get_type_code(const ASR::ttype_t *t, bool use_underscore_sep=false,
-    bool encode_dimensions_=true)
+    bool encode_dimensions_=true, bool set_dimensional_hint=true)
 {
+    bool is_dimensional = false;
+    std::string res = "";
     switch (t->type) {
         case ASR::ttypeType::Integer: {
             ASR::Integer_t *integer = ASR::down_cast<ASR::Integer_t>(t);
-            std::string res = "i" + std::to_string(integer->m_kind * 8);
+            res = "i" + std::to_string(integer->m_kind * 8);
             if( encode_dimensions_ ) {
                 encode_dimensions(integer->n_dims, res, use_underscore_sep);
+                return res;
             }
-            return res;
+            is_dimensional = integer->n_dims > 0;
+            break;
         }
         case ASR::ttypeType::Real: {
             ASR::Real_t *real = ASR::down_cast<ASR::Real_t>(t);
-            std::string res = "r" + std::to_string(real->m_kind * 8);
+            res = "r" + std::to_string(real->m_kind * 8);
             if( encode_dimensions_ ) {
                 encode_dimensions(real->n_dims, res, use_underscore_sep);
+                return res;
             }
-            return res;
+            is_dimensional = real->n_dims > 0;
+            break;
         }
         case ASR::ttypeType::Complex: {
             ASR::Complex_t *complx = ASR::down_cast<ASR::Complex_t>(t);
-            std::string res = "c" + std::to_string(complx->m_kind * 8);
+            res = "c" + std::to_string(complx->m_kind * 8);
             if( encode_dimensions_ ) {
                 encode_dimensions(complx->n_dims, res, use_underscore_sep);
+                return res;
             }
-            return res;
+            is_dimensional = complx->n_dims > 0;
+            break;
         }
         case ASR::ttypeType::Logical: {
             ASR::Logical_t* bool_ = ASR::down_cast<ASR::Logical_t>(t);
             std::string res = "bool";
             if( encode_dimensions_ ) {
                 encode_dimensions(bool_->n_dims, res, use_underscore_sep);
+                return res;
             }
-            return res;
+            is_dimensional = bool_->n_dims > 0;
+            break;
         }
         case ASR::ttypeType::Character: {
             return "str";
@@ -773,7 +783,8 @@ static inline std::string get_type_code(const ASR::ttype_t *t, bool use_undersco
                 result += "[";
             }
             for (size_t i = 0; i < tup->n_type; i++) {
-                result += get_type_code(tup->m_type[i], use_underscore_sep, encode_dimensions_);
+                result += get_type_code(tup->m_type[i], use_underscore_sep,
+                                        encode_dimensions_, set_dimensional_hint);
                 if (i + 1 != tup->n_type) {
                     if( use_underscore_sep ) {
                         result += "_";
@@ -792,64 +803,80 @@ static inline std::string get_type_code(const ASR::ttype_t *t, bool use_undersco
         case ASR::ttypeType::Set: {
             ASR::Set_t *s = ASR::down_cast<ASR::Set_t>(t);
             if( use_underscore_sep ) {
-                return "set_" + get_type_code(s->m_type, use_underscore_sep, encode_dimensions_) + "_";
+                return "set_" + get_type_code(s->m_type, use_underscore_sep,
+                                              encode_dimensions_, set_dimensional_hint) + "_";
             }
-            return "set[" + get_type_code(s->m_type, use_underscore_sep, encode_dimensions_) + "]";
+            return "set[" + get_type_code(s->m_type, use_underscore_sep,
+                                          encode_dimensions_, set_dimensional_hint) + "]";
         }
         case ASR::ttypeType::Dict: {
             ASR::Dict_t *d = ASR::down_cast<ASR::Dict_t>(t);
             if( use_underscore_sep ) {
-                return "dict_" + get_type_code(d->m_key_type, use_underscore_sep, encode_dimensions_) +
-                    "_" + get_type_code(d->m_value_type, use_underscore_sep, encode_dimensions_) + "_";
+                return "dict_" + get_type_code(d->m_key_type, use_underscore_sep,
+                                               encode_dimensions_, set_dimensional_hint) +
+                    "_" + get_type_code(d->m_value_type, use_underscore_sep,
+                                        encode_dimensions_, set_dimensional_hint) + "_";
             }
-            return "dict[" + get_type_code(d->m_key_type, use_underscore_sep, encode_dimensions_) +
-                    ", " + get_type_code(d->m_value_type, use_underscore_sep, encode_dimensions_) + "]";
+            return "dict[" + get_type_code(d->m_key_type, use_underscore_sep,
+                                           encode_dimensions_, set_dimensional_hint) +
+                    ", " + get_type_code(d->m_value_type, use_underscore_sep,
+                                         encode_dimensions_, set_dimensional_hint) + "]";
         }
         case ASR::ttypeType::List: {
             ASR::List_t *l = ASR::down_cast<ASR::List_t>(t);
             if( use_underscore_sep ) {
-                return "list_" + get_type_code(l->m_type, use_underscore_sep, encode_dimensions_) + "_";
+                return "list_" + get_type_code(l->m_type, use_underscore_sep,
+                                               encode_dimensions_, set_dimensional_hint) + "_";
             }
-            return "list[" + get_type_code(l->m_type, use_underscore_sep, encode_dimensions_) + "]";
+            return "list[" + get_type_code(l->m_type, use_underscore_sep,
+                                           encode_dimensions_, set_dimensional_hint) + "]";
         }
         case ASR::ttypeType::CPtr: {
             return "CPtr";
         }
         case ASR::ttypeType::Struct: {
             ASR::Struct_t* d = ASR::down_cast<ASR::Struct_t>(t);
-            std::string res = symbol_name(d->m_derived_type);
+            res = symbol_name(d->m_derived_type);
             if( encode_dimensions_ ) {
                 encode_dimensions(d->n_dims, res, use_underscore_sep);
+                return res;
             }
-            return res;
+            is_dimensional = d->n_dims > 0;
+            break;
         }
         case ASR::ttypeType::Union: {
             ASR::Union_t* d = ASR::down_cast<ASR::Union_t>(t);
-            std::string res = symbol_name(d->m_union_type);
+            res = symbol_name(d->m_union_type);
             if( encode_dimensions_ ) {
                 encode_dimensions(d->n_dims, res, use_underscore_sep);
+                return res;
             }
-            return res;
+            is_dimensional = d->n_dims > 0;
+            break;
         }
         case ASR::ttypeType::Pointer: {
             ASR::Pointer_t* p = ASR::down_cast<ASR::Pointer_t>(t);
             if( use_underscore_sep ) {
-                return "Pointer_" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_) + "_";
+                return "Pointer_" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_, set_dimensional_hint) + "_";
             }
-            return "Pointer[" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_) + "]";
+            return "Pointer[" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_, set_dimensional_hint) + "]";
         }
         case ASR::ttypeType::Const: {
             ASR::Const_t* p = ASR::down_cast<ASR::Const_t>(t);
             if( use_underscore_sep ) {
-                return "Const_" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_) + "_";
+                return "Const_" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_, set_dimensional_hint) + "_";
             }
-            return "Const[" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_) + "]";
+            return "Const[" + get_type_code(p->m_type, use_underscore_sep, encode_dimensions_, set_dimensional_hint) + "]";
         }
         default: {
             throw LCompilersException("Type encoding not implemented for "
                                       + std::to_string(t->type));
         }
     }
+    if( is_dimensional && set_dimensional_hint ) {
+        res += "dim";
+    }
+    return res;
 }
 
 static inline std::string get_type_code(ASR::ttype_t** types, size_t n_types,
diff --git a/src/libasr/codegen/asr_to_c.cpp b/src/libasr/codegen/asr_to_c.cpp
@@ -381,12 +381,15 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
                     bool is_fixed_size = true;
                     dims = convert_dims_c(t->n_dims, t->m_dims, v.m_type, is_fixed_size, true);
                     std::string encoded_type_name = "i" + std::to_string(t->m_kind * 8);
+                    bool is_struct_type_member = ASR::is_a<ASR::StructType_t>(
+                         *ASR::down_cast<ASR::symbol_t>(v.m_parent_symtab->asr_owner));
                     generate_array_decl(sub, std::string(v.m_name), type_name, dims,
                                         encoded_type_name, t->m_dims, t->n_dims,
                                         use_ref, dummy,
                                         v.m_intent != ASRUtils::intent_in &&
                                         v.m_intent != ASRUtils::intent_inout &&
-                                        v.m_intent != ASRUtils::intent_out, is_fixed_size);
+                                        v.m_intent != ASRUtils::intent_out &&
+                                        !is_struct_type_member, is_fixed_size);
                 } else {
                     bool is_fixed_size = true;
                     dims = convert_dims_c(t->n_dims, t->m_dims, v.m_type, is_fixed_size);
@@ -400,12 +403,15 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
                     bool is_fixed_size = true;
                     dims = convert_dims_c(t->n_dims, t->m_dims, v.m_type, is_fixed_size, true);
                     std::string encoded_type_name = "r" + std::to_string(t->m_kind * 8);
+                    bool is_struct_type_member = ASR::is_a<ASR::StructType_t>(
+                         *ASR::down_cast<ASR::symbol_t>(v.m_parent_symtab->asr_owner));
                     generate_array_decl(sub, std::string(v.m_name), type_name, dims,
                                         encoded_type_name, t->m_dims, t->n_dims,
                                         use_ref, dummy,
                                         v.m_intent != ASRUtils::intent_in &&
                                         v.m_intent != ASRUtils::intent_inout &&
-                                        v.m_intent != ASRUtils::intent_out, is_fixed_size);
+                                        v.m_intent != ASRUtils::intent_out &&
+                                        !is_struct_type_member, is_fixed_size);
                 } else {
                     bool is_fixed_size = true;
                     dims = convert_dims_c(t->n_dims, t->m_dims, v.m_type, is_fixed_size);
@@ -819,6 +825,7 @@ R"(
     }
 
     void visit_StructType(const ASR::StructType_t& x) {
+        src = "";
         std::string c_type_name = "struct";
         if( x.m_is_packed ) {
             std::string attr_args = "(packed";
@@ -835,6 +842,7 @@ R"(
             c_type_name += " __attribute__(" + attr_args + ")";
         }
         visit_AggregateTypeUtil(x, c_type_name);
+        src = "";
     }
 
     void visit_UnionType(const ASR::UnionType_t& x) {
@@ -1102,13 +1110,13 @@ R"(
 
         ASR::ttype_t* array_type_asr = ASRUtils::expr_type(x.m_array);
         std::string array_type_name = CUtils::get_c_type_from_ttype_t(array_type_asr);
-        std::string array_encoded_type_name = ASRUtils::get_type_code(array_type_asr, true, false);
+        std::string array_encoded_type_name = ASRUtils::get_type_code(array_type_asr, true, false, false);
         std::string array_type = get_array_type(array_type_name, array_encoded_type_name, true);
         std::string return_type = get_array_type(array_type_name, array_encoded_type_name, false);
 
         ASR::ttype_t* shape_type_asr = ASRUtils::expr_type(x.m_shape);
         std::string shape_type_name = CUtils::get_c_type_from_ttype_t(shape_type_asr);
-        std::string shape_encoded_type_name = ASRUtils::get_type_code(shape_type_asr, true, false);
+        std::string shape_encoded_type_name = ASRUtils::get_type_code(shape_type_asr, true, false, false);
         std::string shape_type = get_array_type(shape_type_name, shape_encoded_type_name, true);
 
         std::string array_reshape_func = c_utils_functions->get_array_reshape(array_type, shape_type,
diff --git a/src/libasr/codegen/asr_to_llvm.cpp b/src/libasr/codegen/asr_to_llvm.cpp
@@ -617,7 +617,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
             const std::map<std::string, ASR::symbol_t*>& scope = der_type->m_symtab->get_scope();
             for( auto itr = scope.begin(); itr != scope.end(); itr++ ) {
                 ASR::Variable_t* member = (ASR::Variable_t*)(&(itr->second->base));
-                llvm::Type* llvm_mem_type = getMemberType(member->m_type, member);
+                llvm::Type* llvm_mem_type = get_type_from_ttype_t_util(member->m_type);
                 member_types.push_back(llvm_mem_type);
                 name2memidx[der_type_name][std::string(member->m_name)] = member_idx;
                 member_idx++;
@@ -3790,9 +3790,11 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
         if( ASR::is_a<ASR::UnionTypeConstructor_t>(*x.m_value) ) {
             return ;
         }
+        ASR::ttype_t* target_type = ASRUtils::expr_type(x.m_target);
+        ASR::ttype_t* value_type = ASRUtils::expr_type(x.m_value);
         this->visit_expr_wrapper(x.m_value, true);
         if( ASR::is_a<ASR::Var_t>(*x.m_value) &&
-            ASR::is_a<ASR::Union_t>(*ASRUtils::expr_type(x.m_value)) ) {
+            ASR::is_a<ASR::Union_t>(*value_type) ) {
             tmp = LLVM::CreateLoad(*builder, tmp);
         }
         value = tmp;
@@ -3804,12 +3806,12 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 }
             }
         }
-        ASR::ttype_t* target_type = ASRUtils::expr_type(x.m_target);
-        ASR::ttype_t* value_type = ASRUtils::expr_type(x.m_value);
         if( ASRUtils::is_array(target_type) &&
             ASRUtils::is_array(value_type) &&
             ASRUtils::check_equal_type(target_type, value_type) ) {
-            arr_descr->copy_array(value, target);
+            bool create_dim_des_array = !ASR::is_a<ASR::Var_t>(*x.m_target);
+            arr_descr->copy_array(value, target, module.get(),
+                                  target_type, create_dim_des_array);
         } else {
             builder->CreateStore(value, target);
         }
diff --git a/src/libasr/codegen/llvm_array_utils.cpp b/src/libasr/codegen/llvm_array_utils.cpp
diff --git a/src/libasr/codegen/llvm_array_utils.h b/src/libasr/codegen/llvm_array_utils.h
