Fixed field type morphization bugs.

FractalFir · FractalFir · commit 386dcf1a5ca0 · 2023-11-17T19:32:18.000+01:00
diff --git a/src/compile_test.rs b/src/compile_test.rs
@@ -443,7 +443,8 @@ macro_rules! cargo_test_ignored {
                     .current_dir(test_dir)
                     .args([
                         "build",
-                        "--release", //"--target",
+                        "--release",
+                        "-j1" //"--target",
                                      //"clr64-unknown-clr"
                     ])
                     .output()
diff --git a/src/place/adress.rs b/src/place/adress.rs
@@ -39,25 +39,11 @@ pub fn place_elem_adress<'ctx>(
         }
         PlaceElem::Field(index, field_type) => match curr_type {
             PlaceTy::Ty(curr_type) => {
-                let curr_type = crate::utilis::monomorphize(&method_instance, curr_type, tyctx);
-                let gen_field_type = crate::utilis::generic_field_ty(
-                    curr_type,
-                    index.as_u32(),
-                    tyctx,
-                    method_instance,
-                );
                 //TODO: Why was this commented out?
                 let field_type = crate::utilis::monomorphize(&method_instance, *field_type, tyctx);
-                let field_name = field_name(curr_type, index.as_u32());
-                let curr_type = crate::r#type::Type::from_ty(curr_type, tyctx, &method_instance);
-                let curr_type = if let crate::r#type::Type::DotnetType(dotnet_type) = curr_type {
-                    dotnet_type.as_ref().clone()
-                } else {
-                    panic!();
-                };
-
-                let field_desc = FieldDescriptor::boxed(curr_type, gen_field_type, field_name);
-                ((field_type).into(), vec![CILOp::LDFieldAdress(field_desc)])
+                let curr_type = crate::utilis::monomorphize(&method_instance, curr_type, tyctx);
+                let field_desc = crate::utilis::field_descrptor(curr_type,(*index).into(),tyctx,method_instance);
+                ((field_type).into(), vec![CILOp::LDFieldAdress(field_desc.into())])
             }
             PlaceTy::EnumVariant(enm, var_idx) => {
                 let owner = crate::utilis::monomorphize(&method_instance, enm, tyctx);
diff --git a/src/place/body.rs b/src/place/body.rs
@@ -38,28 +38,14 @@ pub fn place_elem_body<'ctx>(
         }
         PlaceElem::Field(index, field_type) => match curr_type {
             PlaceTy::Ty(curr_type) => {
-                let curr_type = crate::utilis::monomorphize(&method_instance, curr_type, tyctx);
-                let gen_field_type = crate::utilis::generic_field_ty(
-                    curr_type,
-                    index.as_u32(),
-                    tyctx,
-                    method_instance,
-                );
                 //TODO: Why was this commented out?
                 let field_type = crate::utilis::monomorphize(&method_instance, *field_type, tyctx);
-                let field_name = field_name(curr_type, index.as_u32());
-                let curr_type = crate::r#type::Type::from_ty(curr_type, tyctx, &method_instance);
-                let curr_type = if let crate::r#type::Type::DotnetType(dotnet_type) = curr_type {
-                    dotnet_type.as_ref().clone()
-                } else {
-                    panic!();
-                };
-
-                let field_desc = FieldDescriptor::boxed(curr_type, gen_field_type, field_name);
+                let curr_type = crate::utilis::monomorphize(&method_instance, curr_type, tyctx);
+                let field_desc = crate::utilis::field_descrptor(curr_type,(*index).into(),tyctx,method_instance);
                 if body_ty_is_by_adress(&field_type) {
-                    ((field_type).into(), vec![CILOp::LDFieldAdress(field_desc)])
+                    ((field_type).into(), vec![CILOp::LDFieldAdress(field_desc.into())])
                 } else {
-                    ((field_type).into(), vec![CILOp::LDField(field_desc)])
+                    ((field_type).into(), vec![CILOp::LDField(field_desc.into())])
                 }
             }
             PlaceTy::EnumVariant(enm, var_idx) => {
diff --git a/src/place/get.rs b/src/place/get.rs
@@ -76,22 +76,8 @@ fn place_elem_get<'a>(
         PlaceElem::Field(index, _field_type) => match curr_type {
             super::PlaceTy::Ty(curr_type) => {
                 let curr_type = crate::utilis::monomorphize(&method_instance, curr_type, ctx);
-                let field_type = crate::utilis::generic_field_ty(
-                    curr_type,
-                    index.as_u32(),
-                    ctx,
-                    method_instance,
-                );
-
-                let field_name = field_name(curr_type, index.as_u32());
-                let curr_type = crate::r#type::Type::from_ty(curr_type, ctx, &method_instance);
-                let curr_type = if let crate::r#type::Type::DotnetType(dotnet_type) = curr_type {
-                    dotnet_type.as_ref().clone()
-                } else {
-                    panic!();
-                };
-                let field_desc = FieldDescriptor::boxed(curr_type, field_type, field_name);
-                vec![CILOp::LDField(field_desc)]
+                let field_desc = crate::utilis::field_descrptor(curr_type,(*index).into(),ctx,method_instance);
+                vec![CILOp::LDField(field_desc.into())]
             }
             super::PlaceTy::EnumVariant(enm, var_idx) => {
                 let owner = crate::utilis::monomorphize(&method_instance, enm, ctx);
diff --git a/src/place/set.rs b/src/place/set.rs
@@ -52,22 +52,8 @@ pub fn place_elem_set<'a>(
         PlaceElem::Field(index, _field_type) => {
             if let PlaceTy::Ty(curr_type) = curr_type {
                 let curr_type = crate::utilis::monomorphize(&method_instance, curr_type, ctx);
-                let field_type = crate::utilis::generic_field_ty(
-                    curr_type,
-                    index.as_u32(),
-                    ctx,
-                    method_instance,
-                );
-                let field_name = field_name(curr_type, index.as_u32());
-
-                let curr_type = crate::r#type::Type::from_ty(curr_type, ctx, &method_instance);
-                let curr_type = if let crate::r#type::Type::DotnetType(dotnet_type) = curr_type {
-                    dotnet_type.as_ref().clone()
-                } else {
-                    panic!();
-                };
-                let field_desc = FieldDescriptor::boxed(curr_type, field_type, field_name);
-                vec![CILOp::STField(field_desc)]
+                let field_desc = crate::utilis::field_descrptor(curr_type,(*index).into(),ctx,method_instance);
+                vec![CILOp::STField(field_desc.into())]
             } else {
                 todo!("Can't set fields of enum variants yet!");
             }
diff --git a/src/type_def.rs b/src/type_def.rs
@@ -3,7 +3,7 @@ use crate::{
     method::Method,
     r#type::{DotnetTypeRef, Type},
     utilis::{enum_tag_size, monomorphize, tag_from_enum_variants},
-    IString,
+    IString, cil_op::FieldDescriptor,
 };
 use rustc_middle::ty::{
     AdtDef, AdtKind, AliasKind, GenericArg, Instance, List, Ty, TyCtxt, TyKind,
@@ -32,6 +32,23 @@ impl TypeDef {
     pub fn set_generic_count(&mut self, generic_count: u32) {
         self.gargc = generic_count;
     }
+    /// Gets a [`FieldDescriptor`] describing to a rust filed at rust field index `rust_field_idx`.
+   pub fn field_desc_from_rust_field_idx(&self,self_tpe_ref:DotnetTypeRef,rust_field_idx:u32)->FieldDescriptor{
+        let mut field_iter = self.fields.iter();
+        // If explicit offsets present, check for enum tags
+        if let Some(offsets) = &self.explicit_offsets{
+            if offsets[0] == 0 && self.fields()[0].0.as_ref() == "_tag"{
+                field_iter.next();
+            }
+        };
+        // Get the nth field
+        let (field_name,field_type) = field_iter.nth(rust_field_idx as usize).expect("`field_desc_from_rust_field_idx` could not find field info!");
+        FieldDescriptor::new(
+            self_tpe_ref,
+            field_type.clone(),
+            field_name.clone(),
+        )
+    }
     pub fn gargc(&self) -> u32 {
         self.gargc
     }
@@ -74,6 +91,8 @@ impl TypeDef {
             explicit_offsets: None,
         }
     }
+    /// Gets the definition from type `ty`. The TypeDef corresponding to `ty` is the last one.
+    // TODO: refactor this!
     pub fn from_ty<'tyctx>(
         ty: Ty<'tyctx>,
         ctx: TyCtxt<'tyctx>,
diff --git a/src/utilis.rs b/src/utilis.rs
@@ -12,7 +12,7 @@ pub const MANAGED_CALL_VIRT_FN_NAME: &str = "rustc_clr_interop_managed_call_virt
 pub fn is_function_magic(name: &str) -> bool {
     name.contains(CTOR_FN_NAME) || name.contains(MANAGED_CALL_FN_NAME)
 }
-use crate::{codegen_error::MethodCodegenError, r#type::DotnetTypeRef};
+use crate::{codegen_error::MethodCodegenError, r#type::{DotnetTypeRef, Type}, type_def::TypeDef, cil_op::FieldDescriptor};
 pub fn skip_binder_if_no_generic_types<T>(binder: Binder<T>) -> Result<T, MethodCodegenError> {
     /*
     if binder
@@ -73,13 +73,33 @@ pub fn monomorphize<'tcx, T: TypeFoldable<TyCtxt<'tcx>> + Clone>(
         EarlyBinder::bind(ty),
     )
 }
+pub fn field_descrptor<'ctx>(
+    owner_ty: Ty<'ctx>,
+    field_idx: u32,
+    ctx: TyCtxt<'ctx>,
+    method_instance: Instance<'ctx>,
+) -> FieldDescriptor {
+    if let TyKind::Tuple(elements) = owner_ty.kind(){
+        assert!(elements.len() < 8,"Tuples with more than 8 elements are not supported!");
+        return FieldDescriptor::new(
+            crate::r#type::tuple_type(&elements.iter().map(|tpe|Type::from_ty(tpe,ctx,&method_instance)).collect::<Vec<_>>()),
+            Type::GenericArg(field_idx),
+            format!("Item{}",field_idx + 1).into(),
+        );
+    }
+    let defs = TypeDef::from_ty(owner_ty, ctx, &method_instance);
+    let type_ref = Type::from_ty(owner_ty, ctx, &method_instance).as_dotnet().expect("Field owner not a dotnet type!");
+    let def = defs.iter().last().expect("`crate::utilis::field_descrptor` called on type without a definition.");
+    def.field_desc_from_rust_field_idx(type_ref,field_idx)
+}
 /// Gets the type of field with index `field_idx`, returning a GenericArg if the types field is generic
 pub fn generic_field_ty<'ctx>(
     owner_ty: Ty<'ctx>,
     field_idx: u32,
     ctx: TyCtxt<'ctx>,
     method_instance: Instance<'ctx>,
 ) -> crate::r#type::Type {
+   
     match owner_ty.kind() {
         TyKind::Adt(adt_def, _) => {
             let ty = ctx
@@ -191,6 +211,8 @@ pub fn compiletime_sizeof(ty: Ty) -> usize {
             _ => todo!("Can't compute compiletime sizeof {int:?}"),
         },
         TyKind::Uint(int) => match int {
+            UintTy::U8 => std::mem::size_of::<u8>(),
+            UintTy::U16 => std::mem::size_of::<u16>(),
             UintTy::U32 => std::mem::size_of::<u32>(),
             UintTy::U128 => std::mem::size_of::<u128>(),
             UintTy::Usize => {
