Reworked handling of statics to preserve more info.

FractalFir · FractalFir · commit a6b07f9bd4b4 · 2025-05-01T23:39:57.000+02:00
diff --git a/cilly/src/bin/asmedit.rs b/cilly/src/bin/asmedit.rs
@@ -360,7 +360,7 @@ fn misolate(asm: &mut Assembly, isolate_id: Interned<MethodRef>) {
 }
 fn parse_id(id: &str, asm: &Assembly) -> Interned<MethodRef> {
     if let Ok(id) = id.parse::<u32>() {
-        unsafe { Interned::from_index(NonZeroU32::new(id).unwrap()) }
+        Interned::from_index(NonZeroU32::new(id).unwrap())
     } else {
         let Some(mut iter) = asm.find_methods_matching(id) else {
             panic!("{id:?} is neithier a method name nor a method id")
diff --git a/cilly/src/v2/asm.rs b/cilly/src/v2/asm.rs
@@ -185,7 +185,9 @@ impl Assembly {
         let method_def_idxs: Box<[_]> = self.method_defs.keys().copied().collect();
         for method in method_def_idxs {
             let mut tmp_method = self.method_def(method).clone();
-            tmp_method.typecheck(self);
+            if let Err(err) = tmp_method.typecheck(self) {
+                eprintln!("{err:?}");
+            };
         }
     }
     #[must_use]
diff --git a/cilly/src/v2/asm_link.rs b/cilly/src/v2/asm_link.rs
@@ -108,10 +108,10 @@ impl Assembly {
             super::Const::Null(cref) => super::Const::Null(self.translate_class_ref(source, *cref)),
             super::Const::ByteBuffer { data, tpe } => {
                 let tpe = self.translate_type(source, source[*tpe]);
-                (super::Const::ByteBuffer {
+                super::Const::ByteBuffer {
                     data: self.alloc_const_data(&source.const_data[*data]),
                     tpe: self.alloc_type(tpe),
-                })
+                }
             }
             _ => cst.clone(),
         }
diff --git a/cilly/src/v2/builtins/atomics.rs b/cilly/src/v2/builtins/atomics.rs
@@ -1,7 +1,7 @@
 use crate::{
     asm::MissingMethodPatcher,
     bimap::Interned,
-    cilnode::{ExtendKind, MethodKind, PtrCastRes},
+    cilnode::{ExtendKind, MethodKind},
     cilroot::BranchCond,
     BasicBlock, BinOp, CILNode, CILRoot, ClassRef, Const, Int, MethodImpl, MethodRef, Type,
 };
diff --git a/cilly/src/v2/builtins/int128/mod.rs b/cilly/src/v2/builtins/int128/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
-    asm::MissingMethodPatcher, cilnode::UnOp, Assembly, BasicBlock, BinOp, BranchCond, CILNode,
-    CILRoot, ClassRef, Const, Int, MethodImpl, Type,
+    asm::MissingMethodPatcher, Assembly, BasicBlock, BinOp, BranchCond, CILNode, CILRoot, ClassRef,
+    Const, Int, MethodImpl, Type,
 };
 
 fn op_direct(
diff --git a/cilly/src/v2/builtins/mod.rs b/cilly/src/v2/builtins/mod.rs
@@ -429,7 +429,8 @@ pub fn insert_exeception_stub(asm: &mut Assembly, patcher: &mut MissingMethodPat
         Some(NonZeroU32::new(8).unwrap()),
         None,
         true,
-    ));
+    ))
+    .unwrap();
     insert_catch_unwind_stub(asm, patcher);
 }
 pub fn insert_exception(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
diff --git a/cilly/src/v2/builtins/simd/binop.rs b/cilly/src/v2/builtins/simd/binop.rs
@@ -1,6 +1,6 @@
 use crate::{
     asm::MissingMethodPatcher, tpe::simd::SIMDElem, Assembly, BasicBlock, BinOp, CILNode, CILRoot,
-    Const, Int, Interned, MethodImpl, MethodRef, Type,
+    Const, Interned, MethodImpl, MethodRef, Type,
 };
 macro_rules! binop {
     ($op_name:ident,$op_dotnet:literal) => {
@@ -108,7 +108,7 @@ fn simd_binop(
 }
 pub fn fallback_simd(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
     simd_binop(
-        |asm, lhs, rhs, elem, res_tpe| {
+        |asm, lhs, rhs, _, res_tpe| {
             let res = asm.biop(lhs, rhs, BinOp::Lt);
             asm.int_cast(
                 res,
@@ -121,7 +121,7 @@ pub fn fallback_simd(asm: &mut Assembly, patcher: &mut MissingMethodPatcher) {
         patcher,
     );
     simd_binop(
-        |asm, lhs, rhs, elem, res_tpe| {
+        |asm, lhs, rhs, _, res_tpe| {
             let res = asm.biop(lhs, rhs, BinOp::Eq);
             asm.int_cast(
                 res,
diff --git a/cilly/src/v2/builtins/simd/eq.rs b/cilly/src/v2/builtins/simd/eq.rs
@@ -1,8 +1,6 @@
 use crate::{
-    asm::MissingMethodPatcher,
-    bimap::Interned,
-    tpe::simd::{SIMDElem, SIMDVector},
-    Assembly, BasicBlock, BinOp, CILNode, CILRoot, Const, MethodImpl, MethodRef, Type,
+    asm::MissingMethodPatcher, bimap::Interned, Assembly, BasicBlock, CILNode, CILRoot, MethodImpl,
+    MethodRef, Type,
 };
 
 use super::dotnet_vec_cast;
diff --git a/cilly/src/v2/c_exporter/mod.rs b/cilly/src/v2/c_exporter/mod.rs
@@ -715,13 +715,15 @@ impl CExporter {
             CILNode::LdStaticField(static_field_idx) => {
                 let field = asm[static_field_idx];
                 let class = asm[field.owner()].clone();
-                let fname = class_member_name(&asm[class.name()], &asm[field.name()]);
+                let fname =
+                    class_member_name(&asm[class.name()], &escape_nonfn_name(&asm[field.name()]));
                 fname.to_string()
             }
             CILNode::LdStaticFieldAdress(static_field_idx) => {
                 let field = asm[static_field_idx];
                 let class = asm[field.owner()].clone();
-                let fname = class_member_name(&asm[class.name()], &asm[field.name()]);
+                let fname =
+                    class_member_name(&asm[class.name()], &escape_nonfn_name(&asm[field.name()]));
                 format!("&{}", fname)
             }
             CILNode::LdFtn(method) => mref_to_name(&asm[method], asm),
@@ -951,7 +953,8 @@ impl CExporter {
             CILRoot::SetStaticField { field, val } => {
                 let field = asm[field];
                 let class = asm[field.owner()].clone();
-                let fname = class_member_name(&asm[class.name()], &asm[field.name()]);
+                let fname =
+                class_member_name(&asm[class.name()], &escape_nonfn_name(&asm[field.name()]));
                 let val = Self::node_to_string(asm[val].clone(), asm, locals, inputs, sig)?;
                 format!("{fname} = {val};")
             }
diff --git a/cilly/src/v2/cilroot.rs b/cilly/src/v2/cilroot.rs
@@ -1,9 +1,8 @@
 use serde::{Deserialize, Serialize};
 
 use super::{
-    bimap::{BiMapIndex, Interned, IntoBiMapIndex},
-    cilnode::IsPure,
-    Assembly, CILNode, FieldDesc, Float, FnSig, Int, MethodRef, StaticFieldDesc, Type,
+    bimap::Interned, cilnode::IsPure, Assembly, CILNode, FieldDesc, Float, FnSig, Int, MethodRef,
+    StaticFieldDesc, Type,
 };
 use crate::{cil_root::CILRoot as V1Root, IString};
 //use crate::cil_node::CILNode as V1Node;
diff --git a/cilly/src/v2/class.rs b/cilly/src/v2/class.rs
@@ -1,7 +1,4 @@
-use super::{
-    bimap::{BiMapIndex, Interned, IntoBiMapIndex},
-    Assembly, Const, IntoAsmIndex, MethodDefIdx, MethodRef, Type,
-};
+use super::{bimap::Interned, Assembly, Const, MethodDefIdx, MethodRef, Type};
 use crate::Access;
 use crate::{utilis::assert_unique, IString};
 use serde::{Deserialize, Serialize};
@@ -859,7 +856,8 @@ fn type_gc() {
         None,
         None,
         true,
-    ));
+    ))
+    .unwrap();
     let name: Interned<IString> = asm.alloc_string("Gone");
     asm.class_def(ClassDef::new(
         name,
@@ -872,7 +870,8 @@ fn type_gc() {
         None,
         None,
         true,
-    ));
+    ))
+    .unwrap();
     assert_eq!(asm.class_defs().len(), 2);
     asm.eliminate_dead_types();
     assert_eq!(asm.class_defs().len(), 1);
diff --git a/cilly/src/v2/field.rs b/cilly/src/v2/field.rs
@@ -2,8 +2,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::IString;
 
-use super::bimap::{BiMapIndex, Interned};
-use super::{bimap::IntoBiMapIndex, Type};
+use super::bimap::Interned;
+use super::Type;
 use super::{ClassRef, Int, IntoAsmIndex};
 
 impl Interned<FieldDesc> {
diff --git a/cilly/src/v2/fnsig.rs b/cilly/src/v2/fnsig.rs
@@ -1,9 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use super::{
-    bimap::{BiMapIndex, IntoBiMapIndex},
-    Type,
-};
+use super::Type;
 #[derive(Hash, PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
 pub struct FnSig {
     inputs: Box<[Type]>,
diff --git a/cilly/src/v2/method.rs b/cilly/src/v2/method.rs
@@ -2,13 +2,12 @@ use fxhash::{FxHashMap, FxHashSet};
 use serde::{Deserialize, Serialize};
 
 use super::{
-    bimap::{BiMapIndex, Interned, IntoBiMapIndex},
+    bimap::Interned,
     cilnode::{IsPure, MethodKind},
     class::ClassDefIdx,
-    Access, Assembly, BasicBlock, CILIterElem, CILNode, ClassDef, ClassRef, FnSig, Int,
-    IntoAsmIndex, Type,
+    Access, Assembly, BasicBlock, CILIterElem, CILNode, ClassRef, FnSig, Int, IntoAsmIndex, Type,
 };
-use crate::{cil_node::CallOpArgs, cilnode::PtrCastRes, iter::TpeIter};
+use crate::{cilnode::PtrCastRes, iter::TpeIter};
 use crate::{CILRoot, IString};
 pub type LocalId = u32;
 #[derive(Hash, PartialEq, Eq, Clone, Debug, Serialize, Deserialize)]
@@ -143,7 +142,7 @@ impl MethodRef {
         )
     }
 
-    pub(crate) fn aligned_free(asm: &mut Assembly) -> Interned<MethodRef> {
+    pub fn aligned_free(asm: &mut Assembly) -> Interned<MethodRef> {
         let void_ptr = asm.nptr(Type::Void);
         let sig = asm.sig([void_ptr], Type::Void);
         let aligned_free = asm.alloc_string("AlignedFree");
@@ -764,7 +763,7 @@ impl MethodImpl {
             let val = asm.alloc_node(CILNode::Call(Box::new((alloc, args, IsPure::NOT))));
             if asm[mref.sig()].output() != sig.output() {
                 match (asm[mref.sig()].output(), sig.output()) {
-                    (Type::Ptr(a), Type::Ptr(b)) => {
+                    (Type::Ptr(a), Type::Ptr(_)) => {
                         let val =
                             asm.alloc_node(CILNode::PtrCast(val, Box::new(PtrCastRes::Ptr(*a))));
                         vec![asm.alloc_root(CILRoot::Ret(val))]
diff --git a/cilly/src/v2/mod.rs b/cilly/src/v2/mod.rs
@@ -2,7 +2,7 @@
 #![allow(clippy::module_name_repetitions)]
 // This lint includes tests for some bizzare reason, so ignoring it seems like the best course of action
 #![allow(clippy::missing_panics_doc)]
-#![warn(missing_docs)]
+//#![warn(missing_docs)]
 pub use super::bimap::Interned;
 use std::path::Path;
 
@@ -24,31 +24,48 @@ pub use tpe::int::Int;
 pub use tpe::Type;
 
 use crate::IString;
-
+/// Assembly
 pub mod asm;
+/// Linker-related code
 pub mod asm_link;
+/// Basic block - the building block of control-flow
 pub mod basic_block;
+/// Interning code
 pub mod bimap;
+/// Builtin intrinsics
 pub mod builtins;
+/// Code exporting C source files
 pub mod c_exporter;
-
+/// Exports modules to IR builders. Used for quickly implementing intrinsics
 pub mod cillyir_exporter;
 pub mod cilnode;
 pub mod cilroot;
+/// Definitons of a value / byref type
 pub mod class;
+/// IR constant
 pub mod cst;
+/// IR field
 pub mod field;
+/// IR functions signature
 pub mod fnsig;
 /// Defines hashable and equable floating point types. All NaNs are compared by bits, and -0.0 != 0.0.
 pub mod hashable;
+/// Exports IR to .NET bytecode
 pub mod il_exporter;
+/// IR iterator
 pub mod iter;
+/// Exports IR to JVM bytecode
 pub mod java_exporter;
 pub mod macros;
+/// IR functions
 pub mod method;
+/// IR function builder
 pub mod method_builder;
+/// IR optimization functions
 pub mod opt;
+/// IR type repr
 pub mod tpe;
+/// IR typechecker
 pub mod typecheck;
 #[test]
 fn types() {
@@ -58,7 +75,7 @@ fn types() {
     assert_eq!(*tpe.deref(&asm).deref(&asm), Type::Int(Int::U8));
 }
 #[test]
-pub fn nodes() {
+fn nodes() {
     let mut asm = Assembly::default();
     let add = asm.biop(Const::I8(2), Const::I8(1), BinOp::Add);
     let mut iter = CILIter::new(asm[add].clone(), &asm);
@@ -83,7 +100,9 @@ pub fn nodes() {
     ));
     assert!(iter.next().is_none());
 }
+/// IL exporter
 pub trait Exporter {
+    /// Export error
     type Error: std::fmt::Debug;
     /// # Errors
     /// Returns an error if the export process failed.
diff --git a/cilly/src/v2/opt/mod.rs b/cilly/src/v2/opt/mod.rs
@@ -710,37 +710,7 @@ impl MethodDef {
         cache: &mut SideEffectInfoCache,
     ) {
         if let MethodImpl::MethodBody { blocks, .. } = self.implementation_mut() {
-            /*let has_targets: FxHashMap<_, bool> = blocks
-                .iter()
-                .map(|block| (block.block_id(), block.targets(asm).next().is_some()))
-                .collect();
-            let blocks_copy: FxHashMap<_, _> = blocks
-                .iter()
-                .map(|block| (block.block_id(), block.clone()))
-                .collect();*/
             for block in blocks.iter_mut() {
-                /* if let CILRoot::Branch(info) =
-                    &asm[*block.roots().last().expect("Blocks can't be empty")]
-                {
-                    if block.roots().iter().all(|root| match &asm[*root] {
-                        CILRoot::StLoc(_, _)
-                        | CILRoot::SourceFileInfo { .. }
-                        | CILRoot::Nop
-                        | CILRoot::SetField(_) => true,
-                        CILRoot::Branch(info) => is_branch_unconditional(&info),
-                        _ => false,
-                    }) {
-                        let (target, _, None) = info.as_ref() else {
-                            continue;
-                        };
-                        // Ret or throw
-                        if !has_targets[target] && blocks_copy[target].roots().len() < 60 {
-                            let roots = block.roots_mut();
-                            roots.pop();
-                            roots.extend(blocks_copy[target].roots());
-                        }
-                    }
-                }*/
                 let Some(handler) = block.handler() else {
                     continue;
                 };
diff --git a/cilly/src/v2/tpe/mod.rs b/cilly/src/v2/tpe/mod.rs
@@ -3,10 +3,7 @@ use std::num::NonZeroU8;
 use serde::{Deserialize, Serialize};
 use simd::SIMDVector;
 
-use super::{
-    bimap::{BiMapIndex, Interned, IntoBiMapIndex},
-    Assembly, ClassRef, Float, FnSig, Int,
-};
+use super::{bimap::Interned, Assembly, ClassRef, Float, FnSig, Int};
 
 pub mod float;
 pub mod int;
diff --git a/cilly/src/v2/typecheck.rs b/cilly/src/v2/typecheck.rs
@@ -137,9 +137,9 @@ pub enum TypeCheckError {
         /// Index of the local.
         loc: u32,
         /// Recived type.
-        got: Type,
+        got: String,
         /// Expected type
-        expected: Type,
+        expected: String,
     },
     /// A comparison of non-prmitive types.
     ValueTypeCompare {
@@ -1006,8 +1006,8 @@ impl CILRoot {
                 if !got.is_assignable_to(expected, asm) {
                     Err(TypeCheckError::LocalAssigementWrong {
                         loc: *loc,
-                        got,
-                        expected,
+                        got: got.mangle(asm),
+                        expected: expected.mangle(asm),
                     })
                 } else {
                     Ok(())
diff --git a/src/aggregate.rs b/src/aggregate.rs
@@ -4,7 +4,7 @@ use crate::{
 };
 use cilly::{
     cil_node::CILNode, cil_root::CILRoot, cilnode::MethodKind, ClassRef, Const, FieldDesc, FnSig,
-    Int, Interned, MethodRef, Type,
+    Int, MethodRef, Type,
 };
 use rustc_abi::FieldIdx;
 use rustc_codegen_clr_place::{place_adress, place_get, place_set};
diff --git a/src/assembly.rs b/src/assembly.rs
diff --git a/src/binop/cmp.rs b/src/binop/cmp.rs
diff --git a/src/lib.rs b/src/lib.rs
diff --git a/src/method.rs b/src/method.rs
diff --git a/src/static_data.rs b/src/static_data.rs
diff --git a/src/terminator/call.rs b/src/terminator/call.rs
diff --git a/src/terminator/intrinsics/mod.rs b/src/terminator/intrinsics/mod.rs
diff --git a/src/terminator/mod.rs b/src/terminator/mod.rs
diff --git a/src/utilis/adt.rs b/src/utilis/adt.rs

Original file line number	Diff line number	Diff line change
`@@ -360,7 +360,7 @@ fn misolate(asm: &mut Assembly, isolate_id: Interned<MethodRef>) {`
`360`	`360`	`}`
`361`	`361`	`fn parse_id(id: &str, asm: &Assembly) -> Interned<MethodRef> {`
`362`	`362`	`if let Ok(id) = id.parse::<u32>() {`
`363`		`- unsafe { Interned::from_index(NonZeroU32::new(id).unwrap()) }`
	`363`	`+ Interned::from_index(NonZeroU32::new(id).unwrap())`
`364`	`364`	`} else {`
`365`	`365`	`let Some(mut iter) = asm.find_methods_matching(id) else {`
`366`	`366`	`panic!("{id:?} is neithier a method name nor a method id")`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,9 @@ impl Assembly {`
`185`	`185`	`let method_def_idxs: Box<[_]> = self.method_defs.keys().copied().collect();`
`186`	`186`	`for method in method_def_idxs {`
`187`	`187`	`let mut tmp_method = self.method_def(method).clone();`
`188`		`- tmp_method.typecheck(self);`
	`188`	`+ if let Err(err) = tmp_method.typecheck(self) {`
	`189`	`+ eprintln!("{err:?}");`
	`190`	`+ };`
`189`	`191`	`}`
`190`	`192`	`}`
`191`	`193`	`#[must_use]`
Original file line number	Diff line number	Diff line change
`@@ -108,10 +108,10 @@ impl Assembly {`
`108`	`108`	`super::Const::Null(cref) => super::Const::Null(self.translate_class_ref(source, *cref)),`
`109`	`109`	`super::Const::ByteBuffer { data, tpe } => {`
`110`	`110`	`let tpe = self.translate_type(source, source[*tpe]);`
`111`		`- (super::Const::ByteBuffer {`
	`111`	`+ super::Const::ByteBuffer {`
`112`	`112`	`data: self.alloc_const_data(&source.const_data[*data]),`
`113`	`113`	`tpe: self.alloc_type(tpe),`
`114`		`- })`
	`114`	`+ }`
`115`	`115`	`}`
`116`	`116`	`_ => cst.clone(),`
`117`	`117`	`}`