Start on name pooling #48

Author: mverleg

src/mango/io/util.rs

@@ -1,7 +1,13 @@
+#[macro_use]
 use regex::Regex;
 use std::cell::RefCell;
 use std::collections::HashMap;
 
+// TODO: Use regex! instead of Regex::new to check at compile time. (Also its not on heap). This is actually slower according to 2y old benchmark though. But semantically makes more sense.
+thread_local!{
+    static re: Regex = Regex::new("abc");
+}
+
 pub struct RegexCache {
     cache: HashMap<String, Regex>,
 }

src/mango/towasm/control/block.rs

@@ -1,6 +1,8 @@
 use mango::towasm::collect::Statement;
 use mango::towasm::control::Label;
 use mango::towasm::util::Name;
+use mango::towasm::util::NamePool;
+use mango::towasm::util::NamePool;
 use mango::towasm::Wasm;
 use std::fs::File;
 use std::io;
@@ -48,10 +50,10 @@ impl Block {
         F: FnOnce(Label) -> Vec<Box<Statement>>,
     {
         // todo: determine name automatically
-        Block::new_named(Name::new("b".to_owned()).unwrap(), statements_gen)
+        Block::new_named(NamePool.borrow_mut().anonymous_prefix("block_"), statements_gen)
     }
 
-    pub fn new_named<F>(name: Rc<Name>, statements_gen: F) -> Box<Self>
+    pub fn new_named<F>(name: Name, statements_gen: F) -> Box<Self>
     where
         F: FnOnce(Label) -> Vec<Box<Statement>>,
     {

src/mango/towasm/util/anonymous.rs

@@ -1,43 +1,43 @@
-use mango::towasm::Wasm;
-use std::fs::File;
-use std::io;
-use std::rc::Rc;
-
-pub enum AnonymousName {
-    Pending(AnonymousToken),
-    Resolved(AnonymousChoice),
-}
-
-pub struct AnonymousToken {
-
-}
-
-pub struct AnonymousChoice {
-
-}
-
-pub struct AnonymousTokenPool {
-    name_tokens: Vec<>
-}
-
-impl Name {
-    pub fn new(name: String) -> Option<Rc<Self>> {
-        // todo: filter out illegal names
-        assert!(!name.starts_with("$"));
-        return Some(Rc::new(Name { name }));
-    }
-
-    pub fn pure_name(&self) -> String {
-        return self.name.to_owned();
-    }
-}
-
-impl Wasm for Name {
-    fn as_wat(&self) -> String {
-        format!("${}", self.name)
-    }
-
-    fn write_wasm(&self, file: &mut File) -> io::Result<()> {
-        unimplemented!()
-    }
-}
+//use mango::towasm::Wasm;
+//use std::fs::File;
+//use std::io;
+//use std::rc::Rc;
+//
+//pub enum AnonymousName {
+//    Pending(AnonymousToken),
+//    Resolved(AnonymousChoice),
+//}
+//
+//pub struct AnonymousToken {
+//
+//}
+//
+//pub struct AnonymousChoice {
+//
+//}
+//
+//pub struct AnonymousTokenPool {
+//    name_tokens: Vec<>
+//}
+//
+//impl Name {
+//    pub fn new(name: String) -> Option<Rc<Self>> {
+//        // todo: filter out illegal names
+//        assert!(!name.starts_with("$"));
+//        return Some(Rc::new(Name { name }));
+//    }
+//
+//    pub fn pure_name(&self) -> String {
+//        return self.name.to_owned();
+//    }
+//}
+//
+//impl Wasm for Name {
+//    fn as_wat(&self) -> String {
+//        format!("${}", self.name)
+//    }
+//
+//    fn write_wasm(&self, file: &mut File) -> io::Result<()> {
+//        unimplemented!()
+//    }
+//}

src/mango/towasm/util/given_name.rs

@@ -1,30 +1,30 @@
-use mango::towasm::Wasm;
-use std::fs::File;
-use std::io;
-use std::rc::Rc;
-
-pub struct GivenName {
-    name: String,
-}
-
-impl GivenName {
-    pub fn new(name: String) -> Option<Rc<Self>> {
-        // todo: filter out illegal names (thread_lcoal!)
-        assert!(!name.starts_with("$"));
-        return Some(Rc::new(GivenName { name }));
-    }
-
-    pub fn pure_name(&self) -> String {
-        return self.name.to_owned();
-    }
-}
-
-impl Wasm for GivenName {
-    fn as_wat(&self) -> String {
-        format!("${}", self.name)
-    }
-
-    fn write_wasm(&self, file: &mut File) -> io::Result<()> {
-        unimplemented!()
-    }
-}
+//use mango::towasm::Wasm;
+//use std::fs::File;
+//use std::io;
+//use std::rc::Rc;
+//
+//pub struct GivenName {
+//    name: String,
+//}
+//
+//impl GivenName {
+//    pub fn new(name: String) -> Option<Rc<Self>> {
+//        // todo: filter out illegal names (thread_lcoal!)
+//        assert!(!name.starts_with("$"));
+//        return Some(Rc::new(GivenName { name }));
+//    }
+//
+//    pub fn pure_name(&self) -> String {
+//        return self.name.to_owned();
+//    }
+//}
+//
+//impl Wasm for GivenName {
+//    fn as_wat(&self) -> String {
+//        format!("${}", self.name)
+//    }
+//
+//    fn write_wasm(&self, file: &mut File) -> io::Result<()> {
+//        unimplemented!()
+//    }
+//}

src/mango/towasm/util/mod.rs

@@ -5,12 +5,8 @@
 /// * Names, anonymous or otherwise, should not conflict.
 /// * It should be possible to provide prefixes.
 /// * Anonymous names should be short.
-
 mod name;
-pub use self::name::Name;
-
-mod given_name;
-pub use self::given_name::GivenName;
+pub use self::name::{KnownName, Name, PendingName, RawName};
 
-mod anonymous;
-pub use self::anonymous::AnonymousName;
+mod pool;
+pub use self::pool::NamePool;

src/mango/towasm/util/name.rs

@@ -1,30 +1,31 @@
 use mango::towasm::Wasm;
-use std::fs::File;
-use std::io;
-use std::rc::Rc;
-use std::hash::Hash;
 use std::cell::RefCell;
+use std::rc::Rc;
 
 #[derive(Hash, PartialEq, Eq)]
 pub struct KnownName {
-    name: String
+    name: String,
 }
 
 impl KnownName {
-    pub fn new(name: String) -> Option<Name> {
-        // todo: filter out illegal names (thread_lcoal!)
-        assert!(!name.starts_with("$"));
-        Some(Rc::new(RefCell::new(RawName::Known(KnownName { name }))))
-    }
+    //    fn new(name: String) -> Option<Name> {
+    //         todo: filter out illegal names (thread_lcoal!)
+    //        assert!(!name.starts_with("$"));
+    //        Some(Rc::new(RefCell::new(RawName::Known(KnownName { name }))))
+    //    }
 }
 
 #[derive(Hash, PartialEq, Eq)]
-pub struct PendingName {}
+pub struct PendingName {
+    prefix: Option<String>,
+    id: u32,
+}
+// TODO: change Hash, Eq etc to only use id, not prefix, since ids are unique anyway
 
 impl PendingName {
-    pub fn new() -> Name {
-        Rc::new(RefCell::new(RawName::Pending()))
-    }
+    //    fn new() -> Name {
+    //        Rc::new(RefCell::new(RawName::Pending()))
+    //    }
 }
 
 #[derive(Hash, PartialEq, Eq)]
@@ -33,4 +34,6 @@ pub enum RawName {
     Pending(PendingName),
 }
 
-type Name = Rc<RefCell<RawName>>;
+impl RawName {}
+
+pub type Name = Rc<RefCell<RawName>>;

src/mango/towasm/util/pool.rs

@@ -1,14 +1,45 @@
+use mango::towasm::util::KnownName;
+use mango::towasm::util::Name;
+use mango::towasm::util::PendingName;
+use std::cell::RefCell;
+use std::collections::HashSet;
+use std::rc::Rc;
 
-pub struct NamePool {
-    names: Vec<Rc<Name>>
+pub struct RawNamePool {
+    counter: u32,
+    names: HashSet<Name>,
 }
 
-impl NamePool {
-    pub fn register(name: Rc<Name>) {
+impl RawNamePool {
+    pub fn new() -> NamePool {
+        Rc::new(RefCell::new(RawNamePool {
+            names: HashSet::with_capacity(512),
+        }))
+    }
 
+    pub fn declare(&self, name: String) -> Result<Name, ()> {
+        return if self.names.contains(name) {
+            Result::Err(())
+        } else {
+            let name: Name = Rc::new(RefCell::new(Name::Known(KnownName { name })));
+            self.names.insert(name.clone());
+            Result::Ok(name)
+        };
     }
 
-    pub fn anonymous() {
+    pub fn reuse(&self, name: String) -> Option<Name> {}
 
+    pub fn anonymous(&self) -> Name {
+        self.counter += 1;
+        let name: Name = Rc::new(RefCell::new(Name::Pending(PendingName {
+            prefix: Option::None,
+            id: self.counter,
+        })));
+        self.names.insert(name);
+        name
     }
+
+    pub fn anonymous_prefix(&self, prefix: String) -> Name {}
 }
+
+pub type NamePool = Rc<RefCell<RawNamePool>>;