// Get the string representation of a UniqueTypeId. This method will fail if
// the id is unknown.
- fn get_unique_type_id_as_string(&self, unique_type_id: UniqueTypeId) -> Rc<String> {
+ fn get_unique_type_id_as_string(&self, unique_type_id: UniqueTypeId) -> Rc<str> {
let UniqueTypeId(interner_key) = unique_type_id;
self.unique_id_interner.get(interner_key)
}
// Trim to size before storing permanently
unique_type_id.shrink_to_fit();
- let key = self.unique_id_interner.intern(unique_type_id);
+ let key = self.unique_id_interner.intern(&unique_type_id);
self.type_to_unique_id.insert(type_, UniqueTypeId(key));
return UniqueTypeId(key);
let enum_variant_type_id = format!("{}::{}",
&self.get_unique_type_id_as_string(enum_type_id),
variant_name);
- let interner_key = self.unique_id_interner.intern(enum_variant_type_id);
+ let interner_key = self.unique_id_interner.intern(&enum_variant_type_id);
UniqueTypeId(interner_key)
}
}
/// somehow.
#[derive(Clone, PartialEq, Hash, PartialOrd, Eq, Ord)]
pub struct InternedString {
- string: Rc<String>,
+ string: Rc<str>,
}
impl InternedString {
#[inline]
pub fn new(string: &'static str) -> InternedString {
InternedString {
- string: Rc::new(string.to_owned()),
- }
- }
-
- #[inline]
- fn new_from_rc_str(string: Rc<String>) -> InternedString {
- InternedString {
- string: string,
+ string: Rc::__from_str(string),
}
}
#[inline]
pub fn new_from_name(name: ast::Name) -> InternedString {
- with_ident_interner(|interner| InternedString::new_from_rc_str(interner.get(name)))
+ with_ident_interner(|interner| InternedString { string: interner.get(name) })
}
}
use ast::Name;
-use std::borrow::Borrow;
use std::collections::HashMap;
use std::rc::Rc;
-#[derive(PartialEq, Eq, Hash)]
-struct RcStr(Rc<String>);
-
-impl Borrow<str> for RcStr {
- fn borrow(&self) -> &str {
- &self.0
- }
-}
-
#[derive(Default)]
pub struct Interner {
- names: HashMap<RcStr, Name>,
- strings: Vec<Rc<String>>,
+ names: HashMap<Rc<str>, Name>,
+ strings: Vec<Rc<str>>,
}
/// When traits can extend traits, we should extend index<Name,T> to get []
this
}
- pub fn intern<T: Borrow<str> + Into<String>>(&mut self, string: T) -> Name {
- if let Some(&name) = self.names.get(string.borrow()) {
+ pub fn intern(&mut self, string: &str) -> Name {
+ if let Some(&name) = self.names.get(string) {
return name;
}
let name = Name(self.strings.len() as u32);
- let string = Rc::new(string.into());
+ let string = Rc::__from_str(string);
self.strings.push(string.clone());
- self.names.insert(RcStr(string), name);
+ self.names.insert(string, name);
name
}
pub fn gensym(&mut self, string: &str) -> Name {
let gensym = Name(self.strings.len() as u32);
// leave out of `names` to avoid colliding
- self.strings.push(Rc::new(string.to_owned()));
+ self.strings.push(Rc::__from_str(string));
gensym
}
gensym
}
- pub fn get(&self, name: Name) -> Rc<String> {
+ pub fn get(&self, name: Name) -> Rc<str> {
self.strings[name.0 as usize].clone()
}
assert_eq!(i.gensym("dog"), Name(4));
// gensym tests again with gensym_copy:
assert_eq!(i.gensym_copy(Name(2)), Name(5));
- assert_eq!(*i.get(Name(5)), "zebra");
+ assert_eq!(&*i.get(Name(5)), "zebra");
assert_eq!(i.gensym_copy(Name(2)), Name(6));
- assert_eq!(*i.get(Name(6)), "zebra");
- assert_eq!(*i.get(Name(0)), "dog");
- assert_eq!(*i.get(Name(1)), "cat");
- assert_eq!(*i.get(Name(2)), "zebra");
- assert_eq!(*i.get(Name(3)), "zebra");
- assert_eq!(*i.get(Name(4)), "dog");
+ assert_eq!(&*i.get(Name(6)), "zebra");
+ assert_eq!(&*i.get(Name(0)), "dog");
+ assert_eq!(&*i.get(Name(1)), "cat");
+ assert_eq!(&*i.get(Name(2)), "zebra");
+ assert_eq!(&*i.get(Name(3)), "zebra");
+ assert_eq!(&*i.get(Name(4)), "dog");
}
}