Refactoring traits for garbage collection. Incomplete.

macros/src/lib.rs

@@ -1,56 +1,54 @@
 extern crate proc_macro;
-use proc_macro::{Delimiter, Group, Punct, Ident, TokenStream, TokenTree, Literal, Spacing, Span};
+use map::{DisplacementSet, MapEntry};
 use proc_macro::token_stream::IntoIter;
+use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
 use std::iter::Peekable;
-use map::{DisplacementSet, Equivalent, Hashed, Hashes, MapEntry, TableEntry};
 
 type Tokens = Peekable<IntoIter>;
 
-fn brackets(stream: TokenStream) -> TokenStream {
+fn entry(input: &mut Tokens) -> Option<MapEntry<String, TokenStream>> {
-    TokenStream::from(TokenTree::Group(Group::new(Delimiter::Brace,stream)))
+    if input.peek().is_some() {
-}
+        let index = match input.next() {
-
+            // Take one literal as an index
-fn entry(input: &mut Tokens) -> Option<MapEntry<String,TokenStream>> {
-    if let Some(token) = input.peek() {
-        let index = match input.next() { // Take one literal as an index
             Some(TokenTree::Literal(literal)) => literal.to_string(),
             Some(_) => panic!("Expected literal index"),
             None => return None,
         };
-        match input.next() { // Look for '=' in "=>"
+        match input.next() {
-            Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {},
+            // Look for '=' in "=>"
+            Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {}
             _ => panic!("Expected '=>'"),
         };
-        match input.next() { // Look for '>' in "=>"
+        match input.next() {
-            Some(TokenTree::Punct(punct)) if punct.as_char() == '>' => {},
+            // Look for '>' in "=>"
+            Some(TokenTree::Punct(punct)) if punct.as_char() == '>' => {}
             _ => panic!("Expected '=>'"),
         };
         let mut value = Vec::new();
         let mut closure = false;
-        loop { // Accumulate value token stream until ',' is found
+        loop {
+            // Accumulate value token stream until ',' is found
             match input.next() {
                 Some(TokenTree::Punct(punct)) if punct.as_char() == ',' && !closure => break,
-                Some(ref it@TokenTree::Punct(ref punct)) if punct.as_char() == '|' => {
+                Some(ref it @ TokenTree::Punct(ref punct)) if punct.as_char() == '|' => {
                     value.push(it.clone());
                     closure = !closure
-                },
+                }
                 Some(it) => value.push(it),
                 None => break,
             }
         }
         let mut value_stream = TokenStream::new();
         value_stream.extend(value);
-        Some(MapEntry(Some((
+        Some(MapEntry(Some((index, value_stream))))
-            index,
-            value_stream,
-        ))))
     } else {
         None
     }
 }
 
 #[proc_macro]
-pub fn map(input: TokenStream) -> TokenStream { // todo: only works for string literals right now
+pub fn map(input: TokenStream) -> TokenStream {
+    // todo: only works for string literals right now
     let mut tokens = input.into_iter().peekable();
     let mut entries = DisplacementSet::new();
     while let Some(entry) = entry(&mut tokens) {
@@ -62,34 +60,35 @@ pub fn map(input: TokenStream) -> TokenStream { // todo: only works for string l
             let mut inner = TokenStream::new();
             inner.extend(vec![
                 TokenTree::Literal(Literal::string(entry.0.as_str())),
-                TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+                TokenTree::Punct(Punct::new(',', Spacing::Alone)),
             ]);
             inner.extend(entry.1);
-            let inner = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Parenthesis,inner)));
+            let inner =
+                TokenStream::from(TokenTree::Group(Group::new(Delimiter::Parenthesis, inner)));
             let mut option = TokenStream::new();
             option.extend(vec![
-                TokenTree::Ident(Ident::new("Some",Span::mixed_site())),
+                TokenTree::Ident(Ident::new("Some", Span::mixed_site())),
-                TokenTree::Group(Group::new(Delimiter::Parenthesis,inner))
+                TokenTree::Group(Group::new(Delimiter::Parenthesis, inner)),
             ]);
             option
         } else {
-            TokenStream::from(TokenTree::Ident(Ident::new("None",Span::mixed_site())))
+            TokenStream::from(TokenTree::Ident(Ident::new("None", Span::mixed_site())))
         };
         let mut set_entry = TokenStream::new();
         set_entry.extend(vec![
-            TokenTree::Ident(Ident::new("entry",Span::mixed_site())),
+            TokenTree::Ident(Ident::new("entry", Span::mixed_site())),
-            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-            TokenTree::Ident(Ident::new("MapEntry",Span::mixed_site())),
+            TokenTree::Ident(Ident::new("MapEntry", Span::mixed_site())),
-            TokenTree::Group(Group::new(Delimiter::Parenthesis,option)),
+            TokenTree::Group(Group::new(Delimiter::Parenthesis, option)),
-            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
-            TokenTree::Ident(Ident::new("home",Span::mixed_site())),
+            TokenTree::Ident(Ident::new("home", Span::mixed_site())),
-            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(':', Spacing::Alone)),
             TokenTree::Literal(Literal::usize_unsuffixed(entry.home)),
-            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
-            TokenTree::Ident(Ident::new("displacement",Span::mixed_site())),
+            TokenTree::Ident(Ident::new("displacement", Span::mixed_site())),
-            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(':', Spacing::Alone)),
             TokenTree::Literal(Literal::usize_unsuffixed(entry.displacement as usize)),
-            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
         ]);
         elements.extend(vec![
             /*TokenTree::Ident(Ident::new("deimos",Span::mixed_site())),
@@ -98,11 +97,10 @@ pub fn map(input: TokenStream) -> TokenStream { // todo: only works for string l
             TokenTree::Ident(Ident::new("map",Span::mixed_site())),
             TokenTree::Punct(Punct::new(':',Spacing::Joint)),
             TokenTree::Punct(Punct::new(':',Spacing::Joint)),*/
-            TokenTree::Ident(Ident::new("Entry",Span::mixed_site())),
+            TokenTree::Ident(Ident::new("Entry", Span::mixed_site())),
-            TokenTree::Group(Group::new(Delimiter::Brace,set_entry)),
+            TokenTree::Group(Group::new(Delimiter::Brace, set_entry)),
-            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
         ])
     }
-    let mut array = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Bracket,elements)));
+    TokenStream::from(TokenTree::Group(Group::new(Delimiter::Bracket, elements)))
-    array
 }

src/gc.rs

@@ -1,307 +1,324 @@
-use std::hash::{DefaultHasher, Hash, Hasher};
-use std::marker::{PhantomData};
-use std::ops::{Deref, DerefMut};
 use map::{Hashed, Hashes};
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
 
 type Index = u32;
 
 pub struct FreeList<T> {
-  items: Vec<Option<Header<T>>>,
+    items: Vec<Option<Header<T>>>,
-  free: Vec<Index>,
+    free: Vec<Index>,
-  count: u32,
+    _count: u32,
 }
 
-#[derive(Clone,Debug)]
+#[derive(Clone, Debug)]
 pub struct AnyId {
-  pub(crate) index: Index
+    pub(crate) index: Index,
 }
 
 impl PartialEq for AnyId {
-  fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Self) -> bool {
-    self.index == other.index
+        self.index == other.index
-  }
+    }
 }
 
 impl<T> From<AnyId> for Id<T> {
-  fn from(value: AnyId) -> Self {
+    fn from(value: AnyId) -> Self {
-    Id {
+        Id {
-      index: value.index,
+            index: value.index,
-      phantom_data: PhantomData,
+            phantom_data: PhantomData,
+        }
     }
-  }
 }
 
 #[derive(Debug)]
 pub struct Id<T> {
-  pub(crate) index: Index,
+    pub(crate) index: Index,
-  phantom_data: PhantomData<T>,
+    phantom_data: PhantomData<T>,
 }
 
 pub struct RefId<'a, T> {
-  pub id: Id<T>,
+    pub id: Id<T>,
-  it: &'a mut T
+    it: &'a mut T,
 }
 
 impl<'a, T> Deref for RefId<'a, T> {
-  type Target = T;
+    type Target = T;
 
-  fn deref(&self) -> &Self::Target {
+    fn deref(&self) -> &Self::Target {
-    self.it
+        self.it
-  }
+    }
 }
 
 impl<'a, T> DerefMut for RefId<'a, T> {
-
+    fn deref_mut(&mut self) -> &mut Self::Target {
-  fn deref_mut(&mut self) -> &mut Self::Target {
+        self.it
-    self.it
+    }
-  }
 }
 
 impl<T> From<RefId<'_, T>> for Id<T> {
-  fn from(value: RefId<T>) -> Self {
+    fn from(value: RefId<T>) -> Self {
-    value.id
+        value.id
-  }
+    }
 }
 
 impl<T> Clone for Id<T> {
-  fn clone(&self) -> Self {
+    fn clone(&self) -> Self {
-    Id {
+        Id {
-      index: self.index,
+            index: self.index,
-      phantom_data: PhantomData::default(),
+            phantom_data: PhantomData::default(),
+        }
     }
-  }
 }
 
 impl<T> PartialEq for Id<T> {
-  fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Self) -> bool {
-    self.index == other.index
+        self.index == other.index
-  }
+    }
 }
 
 impl<T> Eq for Id<T> {}
 
 impl<T> Hash for Id<T> {
-  fn hash<H: Hasher>(&self, state: &mut H) {
+    fn hash<H: Hasher>(&self, state: &mut H) {
-    self.index.hash(state)
+        self.index.hash(state)
-  }
+    }
 }
 
 impl<T> Id<T> {
-  pub fn maybe(self) -> MaybeId<T> {
+    pub fn maybe(self) -> MaybeId<T> {
-    MaybeId(self)
+        MaybeId(self)
-  }
+    }
-  pub fn any(self) -> AnyId { AnyId {
+    pub fn any(self) -> AnyId {
-    index: self.index
+        AnyId { index: self.index }
-  }  }
+    }
 }
 
 #[derive(Debug)]
 pub struct MaybeId<T>(Id<T>);
 
 impl<T> From<Id<T>> for MaybeId<T> {
-  fn from(value: Id<T>) -> Self {
+    fn from(value: Id<T>) -> Self {
-    MaybeId(value)
+        MaybeId(value)
-  }
+    }
 }
 
 impl<T> Clone for MaybeId<T> {
-  fn clone(&self) -> Self {
+    fn clone(&self) -> Self {
-    if self.0.index != u32::MAX {
+        if self.0.index != u32::MAX {
-      MaybeId(self.0.clone())
+            MaybeId(self.0.clone())
-    } else {
+        } else {
-      MaybeId::NULL
+            MaybeId::NULL
+        }
     }
-  }
 }
 
 impl<T> PartialEq for MaybeId<T> {
-  fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Self) -> bool {
-    self.0 == other.0
+        self.0 == other.0
-  }
+    }
 }
 
 impl<T> MaybeId<T> {
-  pub const NULL: MaybeId<T> = MaybeId(Id { index: u32::MAX, phantom_data: PhantomData {}, });
+    pub const NULL: MaybeId<T> = MaybeId(Id {
-  pub fn unwrap(self) -> Id<T> {
+        index: u32::MAX,
-    if self.0.index == u32::MAX {
+        phantom_data: PhantomData {},
-      panic!()
+    });
-    } else {
+    pub fn unwrap(self) -> Id<T> {
-      self.0
+        if self.0.index == u32::MAX {
+            panic!()
+        } else {
+            self.0
+        }
     }
-  }
+    pub fn exists(&self) -> Option<Id<T>> {
-  pub fn exists(&self) -> Option<Id<T>> {
+        if self.0.index == u32::MAX {
-    if self.0.index == u32::MAX {
+            None
-      None
+        } else {
-    } else {
+            Some(self.0.clone())
-      Some(self.0.clone())
+        }
     }
-  }
 }
 
 impl<T> Default for FreeList<T> {
-  fn default() -> Self {
+    fn default() -> Self {
-    Self::new()
+        Self::new()
-  }
+    }
 }
 
 impl<T> FreeList<T> {
-  pub fn new() -> FreeList<T> {
+    pub fn new() -> FreeList<T> {
-    FreeList {
+        FreeList {
-      items: Vec::new(),
+            items: Vec::new(),
-      free: Vec::new(),
+            free: Vec::new(),
-      count: 0,
+            _count: 0,
+        }
     }
-  }
+    pub fn get(&mut self, id: &Id<T>) -> &mut T {
-  pub fn get(&mut self, id: &Id<T>) -> &mut T {
+        &mut self.items[id.index as usize].as_mut().unwrap().it
-    &mut self.items[id.index as usize].as_mut().unwrap().it
+    }
-  }
+    pub fn get_ref(&mut self, id: Id<T>) -> RefId<'_, T> {
-  pub fn get_ref(&mut self, id: Id<T>) -> RefId<'_, T> {
+        let it = self.get(&id);
-    let it = self.get(&id);
+        RefId { id, it }
-    RefId { id, it }
+    }
-  }
+    pub fn remove(&mut self, id: &Id<T>) -> T {
-  pub fn remove(&mut self, id: &Id<T>) -> T {
+        self.free.push(id.index);
-    self.free.push(id.index);
+        self.items[id.index as usize].take().unwrap().it
-    self.items[id.index as usize].take().unwrap().it
+    }
-  }
+    pub fn make(&mut self, value: T) -> RefId<'_, T> {
-  pub fn make(&mut self, value: T) -> RefId<'_, T> { // todo: shouldn't panic if allocation fails
+        // todo: shouldn't panic if allocation fails
-    if let Some(free) = self.free.pop() {
+        if let Some(free) = self.free.pop() {
-      self.items[free as usize] = Some(Header::new(value));
+            self.items[free as usize] = Some(Header::new(value));
-      RefId {
+            RefId {
-        id: Id {
+                id: Id {
-          index: free,
+                    index: free,
-          phantom_data: PhantomData,
+                    phantom_data: PhantomData,
-        },
+                },
-        it: &mut self.items[free as usize].as_mut().unwrap().it,
+                it: &mut self.items[free as usize].as_mut().unwrap().it,
-      }
+            }
-    } else {
+        } else {
-      self.items.push(Some(Header::new(value)));
+            self.items.push(Some(Header::new(value)));
-      let index = (self.items.len() - 1) as Index;
+            let index = (self.items.len() - 1) as Index;
-      RefId {
+            RefId {
-        id: Id {
+                id: Id {
-          index,
+                    index,
-          phantom_data: PhantomData,
+                    phantom_data: PhantomData,
-        },
+                },
-        it: &mut self.items[index as usize].as_mut().unwrap().it,
+                it: &mut self.items[index as usize].as_mut().unwrap().it,
-      }
+            }
+        }
     }
-  }
 }
 
 pub struct IdNode<T> {
-  item: T,
+    item: T,
-  next: MaybeId<IdNode<T>>,
+    next: MaybeId<IdNode<T>>,
 }
 
-impl<T,C> Traverse<C> for IdNode<T> where C: Allocates<Self> {
+impl<T, C> Traverse<C> for IdNode<T>
-  fn traverse(id: &Id<IdNode<T>>, context: &mut C) {
+where
-    if let Some(ref next) = context.freelist().get(&id).next.exists() {
+    C: Allocates<Self>,
-      IdNode::traverse(next,context)
+{
+    fn traverse(id: &Id<IdNode<T>>, context: &mut C) {
+        if let Some(ref next) = context.freelist().get(&id).next.exists() {
+            IdNode::traverse(next, context)
+        }
     }
-  }
-
-  fn collect(self) {
-    todo!()
-  }
 }
 
 #[derive(Clone)]
 pub struct LinkedList<T> {
-  first: MaybeId<IdNode<T>>,
+    first: MaybeId<IdNode<T>>,
-  count: Index,
+    count: Index,
 }
 
 impl<T> Default for LinkedList<T> {
-  fn default() -> Self {
+    fn default() -> Self {
-    LinkedList {
+        LinkedList {
-      first: MaybeId::NULL,
+            first: MaybeId::NULL,
-      count: 0,
+            count: 0,
+        }
     }
-  }
 }
 
 impl<T> LinkedList<T> {
-  pub fn new() -> LinkedList<T> {
+    pub fn new() -> LinkedList<T> {
-    LinkedList {
+        LinkedList {
-      first: MaybeId::NULL,
+            first: MaybeId::NULL,
-      count: 0,
+            count: 0,
-    }
-  }
-  pub fn add(&mut self, list: &mut FreeNodeList<T>, it: T) {
-    let old = std::mem::replace(&mut self.first,list.make(IdNode {
-      item: it,
-      next: MaybeId::NULL,
-    }).id.maybe());
-    list.get(&self.first.clone().unwrap()).next = old; // todo: this is painful
-    self.count += 1;
-  }
-  pub fn remove<F>(&mut self, list: &mut FreeNodeList<T>, criteria: F) -> T where T: PartialEq, F: Fn(&T) -> bool {
-    // Find some occurrence of 'item' in the list, remove and restitch the list, returning its id
-    let mut maybe_last = MaybeId::NULL;
-    let mut maybe_this = self.first.clone();
-    while let Some(this) = maybe_this.exists() {
-      let node = list.remove(&this);
-      let next = node.next.clone();
-      if criteria(&node.item) {
-        self.count -= 1;
-        if let Some(last) = maybe_last.exists() {
-          list.get(&last).next = node.next.clone();
-        } else {
-          self.first = node.next.clone();
         }
-        return node.item;
-      }
-      maybe_last = maybe_this;
-      maybe_this = next;
     }
-    panic!()
+    pub fn add(&mut self, list: &mut FreeNodeList<T>, it: T) {
-  }
+        let old = std::mem::replace(
+            &mut self.first,
+            list.make(IdNode {
+                item: it,
+                next: MaybeId::NULL,
+            })
+            .id
+            .maybe(),
+        );
+        list.get(&self.first.clone().unwrap()).next = old; // todo: this is painful
+        self.count += 1;
+    }
+    pub fn remove<F>(&mut self, list: &mut FreeNodeList<T>, criteria: F) -> T
+    where
+        T: PartialEq,
+        F: Fn(&T) -> bool,
+    {
+        // Find some occurrence of 'item' in the list, remove and restitch the list, returning its id
+        let mut maybe_last = MaybeId::NULL;
+        let mut maybe_this = self.first.clone();
+        while let Some(this) = maybe_this.exists() {
+            let node = list.remove(&this);
+            let next = node.next.clone();
+            if criteria(&node.item) {
+                self.count -= 1;
+                if let Some(last) = maybe_last.exists() {
+                    list.get(&last).next = node.next.clone();
+                } else {
+                    self.first = node.next.clone();
+                }
+                return node.item;
+            }
+            maybe_last = maybe_this;
+            maybe_this = next;
+        }
+        panic!()
+    }
 }
 
 pub type FreeNodeList<T> = FreeList<IdNode<T>>;
 
 #[derive(Clone, Debug, Copy)]
 enum State {
-  Cold,
+    Cold,
-  Warm,
+    _Warm,
 }
 
 #[derive(Debug, Clone)]
 struct Header<T> {
-  state: State,
+    _state: State,
-  it: T,
+    it: T,
 }
 
-impl<T> Header<T> where {
+impl<T> Header<T> {
-  fn new(it: T) -> Header<T> {
+    fn new(it: T) -> Header<T> {
-    Header {
+        Header {
-      state: State::Cold,
+            _state: State::Cold,
-      it,
+            it,
+        }
     }
-  }
 }
 
-pub trait Allocates<T> where Self: Sized, T: Traverse<Self> {
+pub trait Allocates<T>
-  fn collect();
+where
-  fn freelist<'a>(&'a mut self) -> &'a mut FreeList<T>;
+    Self: Sized,
+    T: Traverse<Self>,
+{
+    fn freelist<'a>(&'a mut self) -> &'a mut FreeList<T>;
+    fn get(&mut self, id: &Id<T>) -> &mut T {
+        self.freelist().get(id)
+    }
 }
 
 pub trait Traverse<C>: Sized {
-  fn traverse(id: &Id<Self>, context: &mut C);
+    fn traverse(id: &Id<Self>, context: &mut C);
-  fn collect(self);
+    // fn collect(self);
 }
 
 impl<T> Hashes for Id<T> {
-  fn hashed(&self) -> Hashed {
+    fn hashed(&self) -> Hashed {
-    let mut hasher = DefaultHasher::new();
+        let mut hasher = DefaultHasher::new();
-    self.index.hash(&mut hasher);
+        self.index.hash(&mut hasher);
-    hasher.finish() as Hashed
+        hasher.finish() as Hashed
-  }
+    }
 }
 
 impl Hashes for AnyId {
-  fn hashed(&self) -> Hashed {
+    fn hashed(&self) -> Hashed {
-    let mut hasher = DefaultHasher::new();
+        let mut hasher = DefaultHasher::new();
-    self.index.hash(&mut hasher);
+        self.index.hash(&mut hasher);
-    hasher.finish() as Hashed
+        hasher.finish() as Hashed
-  }
+    }
 }