Extended typechecks, fixed a type bug when creating aggregate thin pointers.

Author: FractalFir

cilly/src/v2/cilroot.rs

@@ -680,6 +680,11 @@ impl CILRoot {
         locals: &[(Option<StringIdx>, TypeIdx)],
     ) -> String {
         match self {
+            Self::StInd(boxed) => {
+                let (addr, val, tpe, is_volitile) = boxed.as_ref();
+                let tpe = tpe.mangle(asm);
+                format!("StInd{{addr:{addr:?},val:{val:?},tpe:{tpe},is_volitile:{is_volitile}}}")
+            }
             Self::StLoc(loc, val) => match locals.get(*loc as usize) {
                 Some((Some(name), tpe)) => format!(
                     "StLoc({loc}: {loc_tpe:?} {name:?}, {val:?})",
@@ -688,7 +693,7 @@ impl CILRoot {
                 ),
                 Some((None, tpe)) => format!(
                     "StLoc({loc}: {loc_tpe},{val:?})",
-                    loc_tpe = asm[*tpe].clone().mangle(asm)
+                    loc_tpe = asm[*tpe].clone().mangle(asm),
                 ),
                 None => format!("{self:?}"),
             },

cilly/src/v2/typecheck.rs

@@ -101,6 +101,14 @@ pub enum TypeCheckError {
         lhs: Type,
         rhs: Type,
     },
+    WriteWrongAddr {
+        addr: Type,
+        tpe: Type,
+    },
+    WriteWrongValue {
+        tpe: Type,
+        value: Type,
+    },
 }
 pub fn typecheck_err_to_string(
     root_idx: super::RootIdx,
@@ -122,8 +130,8 @@ pub fn typecheck_err_to_string(
         .collect();
     let root_string = root.display(asm, sig, locals);
     match root.typecheck(sig, locals, asm){
-        Ok(ok)=> format!("digraph G{{edge [dir=\"back\"];\n{nodes} r{root_idx}  [label = \"{root_string:?}\" color = \"green\"] r{root_idx} ->{root_connections}}}",root_idx = root_idx.as_bimap_index()),
-        Err(err)=> format!("digraph G{{edge [dir=\"back\"];\\n{nodes} r{root_idx}  [label = \"{root_string:?}\n{err:?}\" color = \"red\"] r{root_idx} ->{root_connections}}}",root_idx = root_idx.as_bimap_index()),
+        Ok(ok)=> format!("digraph G{{edge [dir=\"back\"];\n{nodes} r{root_idx}  [label = \"{root_string}\" color = \"green\"] r{root_idx} ->{root_connections}}}",root_idx = root_idx.as_bimap_index()),
+        Err(err)=> format!("digraph G{{edge [dir=\"back\"];\\n{nodes} r{root_idx}  [label = \"{root_string}\n{err:?}\" color = \"red\"] r{root_idx} ->{root_connections}}}",root_idx = root_idx.as_bimap_index()),
    }
 }
 pub fn display_typecheck_err(
@@ -856,6 +864,33 @@ impl CILRoot {
                     Ok(())
                 }
             }
+            Self::StInd(boxed) => {
+                let (addr, value, tpe, _) = boxed.as_ref();
+                let addr = asm[*addr].clone().typecheck(sig, locals, asm)?;
+                let value = asm[*value].clone().typecheck(sig, locals, asm)?;
+                let Some(addr_points_to) = addr.pointed_to().map(|tpe| asm[tpe]) else {
+                    return Err(TypeCheckError::WriteWrongAddr { addr, tpe: *tpe });
+                };
+                if !(tpe.is_assignable_to(addr_points_to, asm)
+                    || addr_points_to
+                        .as_int()
+                        .zip(tpe.as_int())
+                        .is_some_and(|(a, b)| a.as_unsigned() == b.as_unsigned())
+                    || addr_points_to == Type::Bool && *tpe == Type::Int(Int::I8))
+                {
+                    return Err(TypeCheckError::WriteWrongAddr { addr, tpe: *tpe });
+                }
+                if !(value.is_assignable_to(*tpe, asm)
+                    || value
+                        .as_int()
+                        .zip(tpe.as_int())
+                        .is_some_and(|(a, b)| a.as_unsigned() == b.as_unsigned())
+                    || value == Type::Bool && *tpe == Type::Int(Int::I8))
+                {
+                    return Err(TypeCheckError::WriteWrongValue { tpe: *tpe, value });
+                }
+                Ok(())
+            }
             _ => {
                 for node in self.nodes() {
                     asm.get_node(*node).clone().typecheck(sig, locals, asm)?;

src/aggregate.rs

@@ -1,7 +1,7 @@
 use crate::{
     assembly::MethodCompileCtx,
     operand::handle_operand,
-    place::place_get,
+    place::{place_get, place_set},
     r#type::{get_type, pointer_to_is_fat},
     utilis::{adt::set_discr, field_name},
 };
@@ -220,14 +220,14 @@ pub fn handle_aggregate<'tcx>(
                     "data_ty:{data_ty:?} is a zst. That is bizzare, cause it should be a pointer?"
                 );
                 let data_type = ctx.type_from_cache(data_ty);
-                let fat_ptr_type_ptr = ctx.nptr(fat_ptr_type);
+                let ptr_tpe = ctx.type_from_cache(pointee);
                 assert_ne!(data_type, Type::Void);
                 // Pointer is thin, just directly assign
                 return CILNode::SubTrees(Box::new((
-                    [CILRoot::STIndPtr(
-                        init_addr,
-                        handle_operand(data, ctx).cast_ptr(ctx.nptr(fat_ptr_type_ptr)),
-                        Box::new(ctx.nptr(fat_ptr_type)),
+                    [place_set(
+                        target_location,
+                        handle_operand(data, ctx).cast_ptr(ctx.nptr(ptr_tpe)),
+                        ctx,
                     )]
                     .into(),
                     Box::new(place_get(target_location, ctx)),