Debug interner struct

Author: matt-cornell

cobalt-ast/src/types/agg.rs

@@ -773,6 +773,7 @@ impl Type for SizedArray {
             eprintln!("base kind: {}, our int kind: {}, real int kind: {}", base.kind(), self.elem().kind(), types::Int::KIND);
             dbg!(base == self.elem());
             eprintln!("base: {base:p}, elem: {:p}", self.elem());
+            eprintln!("{:?}", types::int::INTERN);
         }
         dbg!(target.is_and::<types::Pointer>(|r| r.base() == self.elem()))
     }

cobalt-ast/src/types/int.rs

@@ -1,5 +1,6 @@
 use super::*;
 use inkwell::IntPredicate::*;
+pub(crate) static INTERN: Interner<(u16, bool)> = Interner::new();
 #[derive(Debug, ConstIdentify, PartialEq, Eq, Hash, Display, RefCastCustom)]
 #[display(fmt = "{}{}", r#"if _0.1 {"u"} else {"i"}"#, "_0.0")]
 #[repr(transparent)]
@@ -9,7 +10,6 @@ impl Int {
     fn from_ref(val: &(u16, bool)) -> &Self;
     pub fn new(bits: u16, unsigned: bool) -> &'static Self {
         eprintln!("new int: {bits}, {unsigned}");
-        static INTERN: Interner<(u16, bool)> = Interner::new();
         let ret = Self::from_ref(INTERN.intern((bits, unsigned)));
         eprintln!("finished making int");
         ret

cobalt-utils/src/intern.rs

@@ -1,7 +1,8 @@
-use hashbrown::raw::*;
+use hashbrown::HashTable;
 use once_cell::sync::Lazy;
 use std::hash::{Hash, Hasher};
 use std::sync::RwLock;
+use std::fmt::{self, Debug, Formatter};
 #[inline]
 fn hash(val: &impl Hash) -> u64 {
     let mut state = std::collections::hash_map::DefaultHasher::default();
@@ -10,27 +11,32 @@ fn hash(val: &impl Hash) -> u64 {
 }
 pub struct Interner<'a, T: PartialEq + Eq + Hash> {
     vec: Lazy<aovec::Aovec<T>>,
-    map: RwLock<RawTable<(&'a T, usize)>>,
+    map: RwLock<HashTable<(&'a T, usize)>>,
+}
+impl<T: Debug + PartialEq + Eq + Hash> Debug for Interner<'_, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Interner").field("map", &self.map.read().unwrap()).finish_non_exhaustive()
+    }
 }
 impl<'a, K: PartialEq + Eq + Hash> Interner<'a, K> {
     pub const fn new() -> Self {
         Self {
             vec: Lazy::new(|| aovec::Aovec::new(16)),
-            map: RwLock::new(RawTable::new()),
+            map: RwLock::new(HashTable::new()),
         }
     }
     pub fn intern(&'a self, key: K) -> &K {
         let hashed = hash(&key);
         let lock = self.map.read().unwrap();
-        if let Some(k) = lock.get(hashed, |v| v.0 == &key).map(|x| x.1) {
+        if let Some(k) = lock.find(hashed, |v| v.0 == &key).map(|x| x.1) {
             &self.vec[k]
         } else {
             eprintln!("creating new element!");
             std::mem::drop(lock);
             let mut lock = self.map.write().unwrap();
             let idx = self.vec.push(key);
             let val = &self.vec[idx];
-            lock.insert(hashed, (val, idx), |v| hash(&v.0));
+            lock.insert_unique(hashed, (val, idx), |v| hash(&v.0));
             val
         }
     }
@@ -45,7 +51,7 @@ impl<'a, K: PartialEq + Eq + Hash> Interner<'a, K> {
         let hashed = hash(&key);
         let lock = self.map.read().unwrap();
         if let Some(k) = lock
-            .get(hashed, |v| key.as_ref() == v.0.as_ref())
+            .find(hashed, |v| key.as_ref() == v.0.as_ref())
             .map(|x| x.1)
         {
             &self.vec[k]
@@ -54,7 +60,7 @@ impl<'a, K: PartialEq + Eq + Hash> Interner<'a, K> {
             let mut lock = self.map.write().unwrap();
             let idx = self.vec.push(key.into());
             let val = &self.vec[idx];
-            lock.insert(hashed, (val, idx), |v| hash(&v.0));
+            lock.insert_unique(hashed, (val, idx), |v| hash(&v.0));
             val
         }
     }