Moved all interners to a common type.

Author: FractalFir

cilly/src/bin/asmedit.rs

@@ -7,14 +7,12 @@ use std::{
 };
 
 use cilly::{
+    asm::{encoded_stats, Assembly},
+    bimap::{Interned, IntoBiMapIndex},
     c_exporter::CExporter,
-    BasicBlock, CILNode, CILRoot, MethodDef,
-    {
-        asm::{encoded_stats, Assembly},
-        cillyir_exporter::CillyIRExpoter,
-        il_exporter::ILExporter,
-        Access, CILIter, MethodImpl, MethodRefIdx,
-    },
+    cillyir_exporter::CillyIRExpoter,
+    il_exporter::ILExporter,
+    Access, BasicBlock, CILIter, CILNode, CILRoot, MethodDef, MethodImpl, MethodRef,
 };
 use fxhash::FxHashSet;
 
@@ -323,7 +321,7 @@ fn is_valid_c(asm: &Assembly, id: u32) -> bool {
         true
     }
 }
-fn misolate(asm: &mut Assembly, isolate_id: MethodRefIdx) {
+fn misolate(asm: &mut Assembly, isolate_id: Interned<MethodRef>) {
     let externs: Vec<_> = asm
         .methods_with(|_, _, def| *def.access() == Access::Extern)
         .map(|(id, _)| id)
@@ -360,9 +358,9 @@ fn misolate(asm: &mut Assembly, isolate_id: MethodRefIdx) {
     *asm = asm.clone().link(Assembly::default());
     asm.remove_dead_statics();
 }
-fn parse_id(id: &str, asm: &Assembly) -> MethodRefIdx {
+fn parse_id(id: &str, asm: &Assembly) -> Interned<MethodRef> {
     if let Ok(id) = id.parse::<u32>() {
-        unsafe { MethodRefIdx::from_raw(NonZeroU32::new(id).unwrap()) }
+        unsafe { 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")

cilly/src/cil_iter.rs

@@ -1,4 +1,4 @@
-use crate::{cil_node::CILNode, cil_root::CILRoot, MethodRefIdx};
+use crate::{bimap::Interned, cil_node::CILNode, cil_root::CILRoot, MethodRef};
 
 #[derive(Debug, Clone, Copy)]
 pub enum CILIterElem<'a> {
@@ -491,12 +491,12 @@ impl<'a> CILIter<'a> {
     }
 }
 pub trait CILIterTrait<'a> {
-    fn call_sites(self) -> impl Iterator<Item = MethodRefIdx>;
+    fn call_sites(self) -> impl Iterator<Item = Interned<MethodRef>>;
     fn nodes(self) -> impl Iterator<Item = &'a CILNode>;
     fn roots(self) -> impl Iterator<Item = &'a CILRoot>;
 }
 impl<'a, T: Iterator<Item = CILIterElem<'a>>> CILIterTrait<'a> for T {
-    fn call_sites(self) -> impl Iterator<Item = MethodRefIdx> {
+    fn call_sites(self) -> impl Iterator<Item = Interned<MethodRef>> {
         self.filter_map(|node| match node {
             CILIterElem::Node(
                 CILNode::Call(call_op_args)

cilly/src/cil_node.rs

@@ -1,30 +1,29 @@
+use crate::bimap::Interned;
 use crate::cilnode::IsPure;
 use crate::cilnode::MethodKind;
 use crate::v2::method::LocalDef;
-use crate::TypeIdx;
+
+use crate::FieldDesc;
 use crate::{
     call,
     cil_root::CILRoot,
     hashable::{HashableF32, HashableF64},
     IString,
 };
-use crate::{
-    Assembly, ClassRef, ClassRefIdx, FieldIdx, FnSig, Int, MethodRef, MethodRefIdx,
-    StaticFieldDesc, Type,
-};
+use crate::{Assembly, ClassRef, FnSig, Int, MethodRef, StaticFieldDesc, Type};
 use serde::{Deserialize, Serialize};
 /// A container for the arguments of a call, callvirt, or newobj instruction.
 #[derive(Clone, Eq, PartialEq, Serialize, Deserialize, Hash, Debug)]
 pub struct CallOpArgs {
     pub args: Box<[CILNode]>,
-    pub site: MethodRefIdx,
+    pub site: Interned<MethodRef>,
     pub is_pure: IsPure,
 }
 
 #[derive(Clone, Eq, PartialEq, Serialize, Deserialize, Debug, Hash)]
 pub enum CILNode {
     /// A translated V2 node.
-    V2(crate::NodeIdx),
+    V2(Interned<crate::v2::CILNode>),
     /// Loads the value of local variable number `n`.
     LDLoc(u32),
     /// Loads the value of argument number `n`.
@@ -108,13 +107,13 @@ pub enum CILNode {
     LDFieldAdress {
         /// Address of the object
         addr: Box<Self>,
-        field: FieldIdx,
+        field: Interned<FieldDesc>,
     },
     /// Loads the value of `field` of the object `addr` points to
     LDField {
         /// Address of the object
         addr: Box<Self>,
-        field: FieldIdx,
+        field: Interned<FieldDesc>,
     },
     /// Adds 2 values together
     Add(Box<Self>, Box<Self>),
@@ -162,12 +161,12 @@ pub enum CILNode {
     Gt(Box<Self>, Box<Self>),
     /// Compares two operands, returning true if lhs < rhs. Unsigned for intigers, unordered(in respect to NaNs) for floats.
     GtUn(Box<Self>, Box<Self>),
-    TemporaryLocal(Box<(TypeIdx, Box<[CILRoot]>, Self)>),
+    TemporaryLocal(Box<(Interned<Type>, Box<[CILRoot]>, Self)>),
 
     SubTrees(Box<(Box<[CILRoot]>, Box<Self>)>),
     LoadAddresOfTMPLocal,
     LoadTMPLocal,
-    LDFtn(MethodRefIdx),
+    LDFtn(Interned<MethodRef>),
     LDTypeToken(Box<Type>),
     NewObj(Box<CallOpArgs>),
     // 24 bytes - too big!
@@ -215,18 +214,18 @@ pub enum CILNode {
     /// Gets the exception. Can only be used in handlers, only once per handler.
     GetException,
     /// Checks if `lhs` is of type `rhs`. If not, throws.
-    CheckedCast(Box<(CILNode, ClassRefIdx)>),
+    CheckedCast(Box<(CILNode, Interned<ClassRef>)>),
     // Checks if `lhs` is of type `rhs`.  Returns a boolean.
-    IsInst(Box<(CILNode, ClassRefIdx)>),
+    IsInst(Box<(CILNode, Interned<ClassRef>)>),
     /// Marks the inner pointer operation as volatile.
     Volatile(Box<Self>),
     UnboxAny(Box<Self>, Box<Type>),
     AddressOfStaticField(Box<StaticFieldDesc>),
-    LdNull(ClassRefIdx),
+    LdNull(Interned<ClassRef>),
 }
 
 impl CILNode {
-    pub fn stack_addr(val: Self, tpe_idx: TypeIdx, _asm: &mut Assembly) -> Self {
+    pub fn stack_addr(val: Self, tpe_idx: Interned<Type>, _asm: &mut Assembly) -> Self {
         CILNode::TemporaryLocal(Box::new((
             tpe_idx,
             [CILRoot::SetTMPLocal { value: val }].into(),
@@ -235,7 +234,7 @@ impl CILNode {
     }
     pub fn ovf_check_tuple(
         asm: &mut Assembly,
-        tuple: ClassRefIdx,
+        tuple: Interned<ClassRef>,
         out_of_range: Self,
         val: Self,
         tpe: Type,
@@ -270,7 +269,7 @@ impl CILNode {
         )))*/
     }
     pub fn create_slice(
-        slice_tpe: ClassRefIdx,
+        slice_tpe: Interned<ClassRef>,
         asm: &mut Assembly,
         metadata: Self,
         ptr: Self,
@@ -360,7 +359,8 @@ impl CILNode {
                     .into(),
                     site: (asm.alloc_methodref(select)),
                     is_pure: crate::cilnode::IsPure::PURE,
-                })).cast_ptr(tpe)
+                }))
+                .cast_ptr(tpe)
             }
             _ => todo!(),
         }
@@ -399,8 +399,8 @@ impl CILNode {
         old_val: Self,
         expected: Self,
         destination_addr: Self,
-        val_desc: FieldIdx,
-        flag_desc: FieldIdx,
+        val_desc: Interned<FieldDesc>,
+        flag_desc: Interned<FieldDesc>,
     ) -> CILRoot {
         // Set the value of the result.
         let set_val = CILRoot::SetField {

cilly/src/cil_root.rs

@@ -1,13 +1,14 @@
+use crate::bimap::Interned;
 use crate::cilnode::IsPure;
 use crate::cilnode::MethodKind;
 use crate::v2::method::LocalDef;
-use crate::TypeIdx;
+use crate::FieldDesc;
 use crate::{
     call,
     cil_node::{CILNode, CallOpArgs},
     AsmString, IString,
 };
-use crate::{Assembly, ClassRef, FieldIdx, FnSig, MethodRef, MethodRefIdx, StaticFieldDesc, Type};
+use crate::{Assembly, ClassRef, FnSig, MethodRef, StaticFieldDesc, Type};
 use serde::{Deserialize, Serialize};
 #[derive(Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Debug)]
 pub enum CILRoot {
@@ -79,13 +80,13 @@ pub enum CILRoot {
     },
 
     Call {
-        site: MethodRefIdx,
+        site: Interned<MethodRef>,
         args: Box<[CILNode]>,
     },
     SetField {
         addr: Box<CILNode>,
         value: Box<CILNode>,
-        desc: FieldIdx,
+        desc: Interned<FieldDesc>,
     },
     SetTMPLocal {
         value: CILNode,
@@ -121,7 +122,7 @@ pub enum CILRoot {
         count: Box<CILNode>,
     },
     CallVirt {
-        site: MethodRefIdx,
+        site: Interned<MethodRef>,
         args: Box<[CILNode]>,
     },
     Ret {
@@ -150,8 +151,8 @@ pub enum CILRoot {
     OptimizedSourceFileInfo(std::ops::Range<u64>, std::ops::Range<u64>, AsmString),
     /// Marks the inner pointer operation as volatile.
     Volatile(Box<Self>),
-    InitObj(CILNode, TypeIdx),
-    V2(crate::RootIdx),
+    InitObj(CILNode, Interned<Type>),
+    V2(Interned<crate::v2::CILRoot>),
 }
 pub type SFI = Box<(std::ops::Range<u64>, std::ops::Range<u64>, IString)>;
 impl CILRoot {
@@ -385,7 +386,7 @@ impl CILRoot {
         Self::SourceFileInfo(Box::new((line, column, file.to_owned().into())))
     }
     #[must_use]
-    pub fn set_field(addr: CILNode, value: CILNode, desc: FieldIdx) -> Self {
+    pub fn set_field(addr: CILNode, value: CILNode, desc: Interned<FieldDesc>) -> Self {
         Self::SetField {
             addr: Box::new(addr),
             value: Box::new(value),

cilly/src/entrypoint.rs

@@ -5,7 +5,7 @@ use crate::{
     {cilnode::MethodKind, Assembly, Int, MethodRef},
 };
 
-/// Creates a wrapper method around entypoint represented by `MethodRefIdx`
+/// Creates a wrapper method around entypoint represented by `Interned<MethodRef>`
 pub fn wrapper(entrypoint: MethodRef, asm: &mut Assembly) -> MethodDefIdx {
     let uint8_ptr = asm.nptr(Type::Int(Int::U8));
     let uint8_ptr_idx = asm.alloc_type(uint8_ptr);

cilly/src/method.rs

@@ -7,11 +7,13 @@ use std::{
 
 use crate::{
     basic_block::BasicBlock,
+    bimap::Interned,
     cil_iter::{CILIterElem, CILIterTrait},
     cil_node::CILNode,
     cil_tree::CILTree,
-    Access, IString, IntoAsmIndex, StringIdx, Type, TypeIdx,
-    {cilnode::MethodKind, v2::method::LocalDef, Assembly, FnSig, MethodRef, MethodRefIdx},
+    cilnode::MethodKind,
+    v2::method::LocalDef,
+    Access, Assembly, FnSig, IString, IntoAsmIndex, MethodRef, Type,
 };
 
 /// Represenation of a CIL method.
@@ -24,7 +26,7 @@ pub struct Method {
     locals: Vec<LocalDef>,
     blocks: Vec<BasicBlock>,
     attributes: Vec<Attribute>,
-    arg_names: Vec<Option<StringIdx>>,
+    arg_names: Vec<Option<Interned<IString>>>,
 }
 
 impl Eq for Method {}
@@ -80,7 +82,7 @@ impl Method {
         name: &str,
         mut locals: Vec<LocalDef>,
         blocks: Vec<BasicBlock>,
-        mut arg_names: Vec<Option<StringIdx>>,
+        mut arg_names: Vec<Option<Interned<IString>>>,
         asm: &mut Assembly,
     ) -> Self {
         let mut used_names = FxHashSet::with_hasher(FxBuildHasher::default());
@@ -126,8 +128,8 @@ impl Method {
     /// Adds a local variable of type `local`
     pub fn add_local(
         &mut self,
-        local: impl IntoAsmIndex<TypeIdx>,
-        name: Option<impl IntoAsmIndex<StringIdx>>,
+        local: impl IntoAsmIndex<Interned<Type>>,
+        name: Option<impl IntoAsmIndex<Interned<IString>>>,
         asm: &mut Assembly,
     ) -> usize {
         let loc = self.locals.len();
@@ -136,7 +138,7 @@ impl Method {
         loc
     }
     /// Extends local variables by `iter`.
-    pub fn extend_locals<'a>(&mut self, iter: impl Iterator<Item = &'a TypeIdx>) {
+    pub fn extend_locals<'a>(&mut self, iter: impl Iterator<Item = &'a Interned<Type>>) {
         self.locals.extend(iter.map(|tpe| (None, *tpe)));
     }
     /// Checks if the method `self` is the entrypoint.
@@ -181,20 +183,20 @@ impl Method {
     }
     /// Returns the list of local types.
     #[must_use]
-    pub fn locals(&self) -> &[(Option<StringIdx>, TypeIdx)] {
+    pub fn locals(&self) -> &[(Option<Interned<IString>>, Interned<Type>)] {
         &self.locals
     }
     /// Returns the list of external calls this function preforms. Calls may repeat.
     // TODO: make this not call `into_ops`
-    pub fn calls(&self) -> impl Iterator<Item = MethodRefIdx> + '_ {
+    pub fn calls(&self) -> impl Iterator<Item = Interned<MethodRef>> + '_ {
         self.blocks
             .iter()
             .flat_map(|block| block.iter_cil())
             .call_sites()
     }
 
     /// Returns a call site that describes this method.
-    pub fn call_site(&self, asm: &mut crate::Assembly) -> MethodRefIdx {
+    pub fn call_site(&self, asm: &mut crate::Assembly) -> Interned<MethodRef> {
         let mref = MethodRef::new(
             *asm.main_module(),
             asm.alloc_string(self.name()),
@@ -222,7 +224,10 @@ impl Method {
         self.attributes.push(attr);
     }
     /// Sets the list of locals of self to `locals`.
-    pub fn set_locals(&mut self, locals: impl Into<Vec<(Option<StringIdx>, TypeIdx)>>) {
+    pub fn set_locals(
+        &mut self,
+        locals: impl Into<Vec<(Option<Interned<IString>>, Interned<Type>)>>,
+    ) {
         self.locals = locals.into();
     }
     /// Returns the type of this method(static, instance or virtual)
@@ -241,7 +246,7 @@ impl Method {
     }
 
     #[must_use]
-    pub fn arg_names(&self) -> &[Option<StringIdx>] {
+    pub fn arg_names(&self) -> &[Option<Interned<IString>>] {
         &self.arg_names
     }
 
@@ -256,8 +261,8 @@ impl Method {
     }
     pub fn alloc_local(
         &mut self,
-        tpe: impl IntoAsmIndex<TypeIdx>,
-        name: Option<impl IntoAsmIndex<StringIdx>>,
+        tpe: impl IntoAsmIndex<Interned<Type>>,
+        name: Option<impl IntoAsmIndex<Interned<IString>>>,
         asm: &mut Assembly,
     ) -> usize {
         let new_loc = self.locals.len();