kill me

Author: matt-cornell

cobalt-ast/src/types/agg.rs

@@ -773,7 +773,6 @@ 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

@@ -10,6 +10,7 @@ impl Int {
     fn from_ref(val: &(u16, bool)) -> &Self;
     pub fn new(bits: u16, unsigned: bool) -> &'static Self {
         eprintln!("new int: {bits}, {unsigned}");
+        eprintln!("INTERN: {INTERN:#?}");
         let ret = Self::from_ref(INTERN.intern((bits, unsigned)));
         eprintln!("finished making int");
         ret

cobalt-utils/Cargo.toml

@@ -9,6 +9,6 @@ description.workspace = true
 documentation.workspace = true
 
 [dependencies]
-aovec = "1.1.0"
+boxcar = "0.2.4"
 hashbrown = { version = "0.14.2", features = ["raw"] }
 once_cell = "1.18.0"

cobalt-utils/src/intern.rs

@@ -2,26 +2,21 @@ 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();
     val.hash(&mut state);
     state.finish()
 }
+#[derive(Debug)]
 pub struct Interner<'a, T: PartialEq + Eq + Hash> {
-    vec: Lazy<aovec::Aovec<T>>,
+    vec: Lazy<boxcar::Vec<T>>,
     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)),
+            vec: Lazy::new(boxcar::Vec::new),
             map: RwLock::new(HashTable::new()),
         }
     }
@@ -32,7 +27,7 @@ impl<'a, K: PartialEq + Eq + Hash> Interner<'a, K> {
             eprintln!("reusing old element @ {k}");
             &self.vec[k]
         } else {
-            eprintln!("creating new element @ {}", self.vec.len());
+            eprintln!("creating new element @ {}", self.vec.count());
             std::mem::drop(lock);
             let mut lock = self.map.write().unwrap();
             let idx = self.vec.push(key);