diff --git a/src/doc/guide-container.md b/src/doc/guide-container.md index ebad650a534..543b77ccdb9 100644 --- a/src/doc/guide-container.md +++ b/src/doc/guide-container.md @@ -38,7 +38,7 @@ order. Each `HashMap` instance has a random 128-bit key to use with a keyed hash, making the order of a set of keys in a given hash table randomized. Rust provides a [SipHash](https://131002.net/siphash/) implementation for any type -implementing the `IterBytes` trait. +implementing the `Hash` trait. ## Double-ended queues @@ -186,12 +186,12 @@ let mut calls = 0; let it = xs.iter().scan((), |_, x| { calls += 1; if *x < 3 { Some(x) } else { None }}); - + // the iterator will only yield 1 and 2 before returning None // If we were to call it 5 times, calls would end up as 5, despite // only 2 values being yielded (and therefore 3 unique calls being // made). The fuse() adaptor can fix this. - + let mut it = it.fuse(); it.next(); it.next(); diff --git a/src/doc/po/ja/tutorial.md.po b/src/doc/po/ja/tutorial.md.po index 34769b320b7..2646460346b 100644 --- a/src/doc/po/ja/tutorial.md.po +++ b/src/doc/po/ja/tutorial.md.po @@ -4421,15 +4421,15 @@ msgstr "" #, fuzzy #| msgid "" #| "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, " -#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, " +#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, " #| "`Zero`, and `ToStr`." msgid "" "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, " -"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, " +"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, " "`Default`, `Zero`, and `ToStr`." msgstr "" "実装を自動的に導出可能なトレイトは、 `Eq`, `TotalEq`, `Ord`, `TotalOrd`, " -"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, `Zero`, " +"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, `Zero`, " "および `ToStr` です。." #. type: Plain text diff --git a/src/doc/rust.md b/src/doc/rust.md index 6d9cb8b5d7b..650bee7d335 100644 --- a/src/doc/rust.md +++ b/src/doc/rust.md @@ -2035,7 +2035,7 @@ Supported traits for `deriving` are: * Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`. * Serialization: `Encodable`, `Decodable`. These require `serialize`. * `Clone` and `DeepClone`, to perform (deep) copies. -* `IterBytes`, to iterate over the bytes in a data type. +* `Hash`, to iterate over the bytes in a data type. * `Rand`, to create a random instance of a data type. * `Default`, to create an empty instance of a data type. * `Zero`, to create an zero instance of a numeric data type. diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md index 304dc1fb5af..59e0bca5a97 100644 --- a/src/doc/tutorial.md +++ b/src/doc/tutorial.md @@ -2525,7 +2525,7 @@ enum ABC { A, B, C } The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`, -`IterBytes`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`. +`Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`. # Crates and the module system diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim index d17f8fc2d87..837a87879b0 100644 --- a/src/etc/vim/syntax/rust.vim +++ b/src/etc/vim/syntax/rust.vim @@ -93,7 +93,6 @@ syn keyword rustTrait GenericPath Path PosixPath WindowsPath syn keyword rustTrait RawPtr syn keyword rustTrait Buffer Writer Reader Seek syn keyword rustTrait Str StrVector StrSlice OwnedStr IntoMaybeOwned -syn keyword rustTrait IterBytes syn keyword rustTrait ToStr IntoStr syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8 diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 94d378b9dc4..0de6eaf53dd 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -15,7 +15,7 @@ use std::num::Bitwise; -#[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)] +#[deriving(Clone, Eq, Hash, ToStr, Encodable, Decodable)] /// A specialized Set implementation to use enum types. pub struct EnumSet { // We must maintain the invariant that no bits are set diff --git a/src/libcollections/hashmap.rs b/src/libcollections/hashmap.rs index 5cdd5bf3812..fe56dbdd2f1 100644 --- a/src/libcollections/hashmap.rs +++ b/src/libcollections/hashmap.rs @@ -54,7 +54,7 @@ use std::cmp::max; use std::fmt; -use std::hash_old::Hash; +use std::hash::{Hash, Hasher, sip}; use std::iter::{FilterMap, Chain, Repeat, Zip}; use std::iter; use std::mem::replace; @@ -79,10 +79,7 @@ struct Bucket { /// hash function for internal state. This means that the order of all hash maps /// is randomized by keying each hash map randomly on creation. /// -/// It is required that the keys implement the `Eq` and `Hash` traits, although -/// this can frequently be achieved by just implementing the `Eq` and -/// `IterBytes` traits as `Hash` is automatically implemented for types that -/// implement `IterBytes`. +/// It is required that the keys implement the `Eq` and `Hash` traits. pub struct HashMap { priv k0: u64, priv k1: u64, @@ -131,14 +128,14 @@ impl HashMap { #[inline] fn bucket_for_key(&self, k: &K) -> SearchResult { - let hash = k.hash_keyed(self.k0, self.k1) as uint; + let hash = sip::hash_with_keys(self.k0, self.k1, k) as uint; self.bucket_for_key_with_hash(hash, k) } #[inline] fn bucket_for_key_equiv>(&self, k: &Q) -> SearchResult { - let hash = k.hash_keyed(self.k0, self.k1) as uint; + let hash = sip::hash_with_keys(self.k0, self.k1, k) as uint; self.bucket_for_key_with_hash_equiv(hash, k) } @@ -339,14 +336,14 @@ impl MutableMap for HashMap { self.expand(); } - let hash = k.hash_keyed(self.k0, self.k1) as uint; + let hash = sip::hash_with_keys(self.k0, self.k1, &k) as uint; self.insert_internal(hash, k, v) } /// Removes a key from the map, returning the value at the key if the key /// was previously in the map. fn pop(&mut self, k: &K) -> Option { - let hash = k.hash_keyed(self.k0, self.k1) as uint; + let hash = sip::hash_with_keys(self.k0, self.k1, k) as uint; self.pop_internal(hash, k) } } @@ -446,7 +443,7 @@ impl HashMap { self.expand(); } - let hash = k.hash_keyed(self.k0, self.k1) as uint; + let hash = sip::hash_with_keys(self.k0, self.k1, &k) as uint; let idx = match self.bucket_for_key_with_hash(hash, &k) { TableFull => fail!("Internal logic error"), FoundEntry(idx) => { found(&k, self.mut_value_for_bucket(idx), a); idx } @@ -925,7 +922,7 @@ pub type SetAlgebraItems<'a, T> = impl< E: Encoder, - K: Encodable + Hash + IterBytes + Eq, + K: Encodable + Hash + Eq, V: Encodable > Encodable for HashMap { fn encode(&self, e: &mut E) { @@ -942,7 +939,7 @@ impl< impl< D: Decoder, - K: Decodable + Hash + IterBytes + Eq, + K: Decodable + Hash + Eq, V: Decodable > Decodable for HashMap { fn decode(d: &mut D) -> HashMap { @@ -960,7 +957,7 @@ impl< impl< S: Encoder, - T: Encodable + Hash + IterBytes + Eq + T: Encodable + Hash + Eq > Encodable for HashSet { fn encode(&self, s: &mut S) { s.emit_seq(self.len(), |s| { @@ -975,7 +972,7 @@ impl< impl< D: Decoder, - T: Decodable + Hash + IterBytes + Eq + T: Decodable + Hash + Eq > Decodable for HashSet { fn decode(d: &mut D) -> HashSet { d.read_seq(|d, len| { diff --git a/src/libcollections/lru_cache.rs b/src/libcollections/lru_cache.rs index d05d2f2d981..ec387df7215 100644 --- a/src/libcollections/lru_cache.rs +++ b/src/libcollections/lru_cache.rs @@ -38,7 +38,7 @@ //! ``` use std::container::Container; -use std::to_bytes::Cb; +use std::hash::{Hash, sip}; use std::ptr; use std::cast; @@ -61,9 +61,9 @@ pub struct LruCache { priv tail: *mut LruEntry, } -impl IterBytes for KeyRef { - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - unsafe{ (*self.k).iter_bytes(lsb0, f) } +impl Hash for KeyRef { + fn hash(&self, s: &mut sip::SipState) { + unsafe {(*self.k).hash(s)} } } @@ -93,7 +93,7 @@ impl LruEntry { } } -impl LruCache { +impl LruCache { /// Create an LRU Cache that holds at most `capacity` items. pub fn new(capacity: uint) -> LruCache { let cache = LruCache { @@ -217,7 +217,7 @@ impl LruCache { } } -impl ToStr for LruCache { +impl ToStr for LruCache { /// Return a string that lists the key-value pairs from most-recently /// used to least-recently used. #[inline] @@ -250,14 +250,14 @@ impl ToStr for LruCache { } } -impl Container for LruCache { +impl Container for LruCache { /// Return the number of key-value pairs in the cache. fn len(&self) -> uint { self.map.len() } } -impl Mutable for LruCache { +impl Mutable for LruCache { /// Clear the cache of all key-value pairs. fn clear(&mut self) { self.map.clear(); diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs index d791e1a2988..2450e22fc10 100644 --- a/src/libextra/stats.rs +++ b/src/libextra/stats.rs @@ -11,7 +11,7 @@ #[allow(missing_doc)]; use std::cmp; -use std::hash_old::Hash; +use std::hash::Hash; use std::io; use std::mem; use std::num; diff --git a/src/libextra/url.rs b/src/libextra/url.rs index 6353e7e1159..41d6d95c6bb 100644 --- a/src/libextra/url.rs +++ b/src/libextra/url.rs @@ -15,7 +15,7 @@ use std::io::BufReader; use std::cmp::Eq; use collections::HashMap; -use std::to_bytes; +use std::hash::{Hash, sip}; use std::uint; /// A Uniform Resource Locator (URL). A URL is a form of URI (Uniform Resource @@ -855,15 +855,15 @@ impl ToStr for Path { } } -impl IterBytes for Url { - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { - self.to_str().iter_bytes(lsb0, f) +impl Hash for Url { + fn hash(&self, s: &mut sip::SipState) { + self.to_str().hash(s) } } -impl IterBytes for Path { - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { - self.to_str().iter_bytes(lsb0, f) +impl Hash for Path { + fn hash(&self, s: &mut sip::SipState) { + self.to_str().hash(s) } } diff --git a/src/libglob/lib.rs b/src/libglob/lib.rs index 3a93b10ad29..819e0949e3b 100644 --- a/src/libglob/lib.rs +++ b/src/libglob/lib.rs @@ -165,12 +165,12 @@ fn list_dir_sorted(path: &Path) -> ~[Path] { /** * A compiled Unix shell style pattern. */ -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)] pub struct Pattern { priv tokens: ~[PatternToken] } -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)] enum PatternToken { Char(char), AnyChar, @@ -179,7 +179,7 @@ enum PatternToken { AnyExcept(~[CharSpecifier]) } -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)] enum CharSpecifier { SingleChar(char), CharRange(char, char) @@ -490,7 +490,7 @@ fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool { /** * Configuration options to modify the behaviour of `Pattern::matches_with(..)` */ -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)] +#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)] pub struct MatchOptions { /** diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 0361b59eb2c..9806c39345b 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -28,7 +28,6 @@ This API is completely unstable and subject to change. html_root_url = "http://static.rust-lang.org/doc/master")]; #[feature(macro_rules, globs, struct_variant, managed_boxes)]; -#[allow(unknown_features)]; // Note: remove it after a snapshot. #[feature(quote)]; extern crate extra; diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 987e052b275..f9f55fbc1bb 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -27,7 +27,8 @@ use middle::typeck; use middle::astencode::vtable_decoder_helpers; use std::u64; -use std::hash_old::Hash; +use std::hash; +use std::hash::Hash; use std::io; use std::io::extensions::u64_from_be_bytes; use std::option; @@ -86,7 +87,7 @@ pub fn maybe_find_item<'a>(item_id: ast::NodeId, } lookup_hash(items, |a| eq_item(a, item_id), - (item_id as i64).hash()) + hash::hash(&(item_id as i64))) } fn find_item<'a>(item_id: ast::NodeId, items: ebml::Doc<'a>) -> ebml::Doc<'a> { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index a32cdbe98a1..733d1de27de 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -26,7 +26,8 @@ use middle; use serialize::Encodable; use std::cast; use std::cell::{Cell, RefCell}; -use std::hash_old::Hash; +use std::hash; +use std::hash::Hash; use std::io::MemWriter; use std::str; use collections::{HashMap, HashSet}; @@ -1380,7 +1381,7 @@ fn encode_info_for_items(ecx: &EncodeContext, // Path and definition ID indexing -fn create_index( +fn create_index( index: ~[entry]) -> ~[@~[entry]] { let mut buckets: ~[@RefCell<~[entry]>] = ~[]; @@ -1388,7 +1389,7 @@ fn create_index( buckets.push(@RefCell::new(~[])); } for elt in index.iter() { - let h = elt.val.hash() as uint; + let h = hash::hash(&elt.val) as uint; let mut bucket = buckets[h % 256].borrow_mut(); bucket.get().push((*elt).clone()); } diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 34008fb84df..6a47743a03f 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -186,7 +186,7 @@ pub struct BorrowStats { // // Note that there is no entry with derefs:3---the type of that expression // is T, which is not a box. -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub struct root_map_key { id: ast::NodeId, derefs: uint @@ -224,13 +224,13 @@ pub enum LoanCause { RefBinding, } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum LoanPath { LpVar(ast::NodeId), // `x` in doc.rs LpExtend(@LoanPath, mc::MutabilityCategory, LoanPathElem) } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum LoanPathElem { LpDeref(mc::PointerKind), // `*LV` in doc.rs LpInterior(mc::InteriorKind) // `LV.f` in doc.rs diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index dddd7505440..c413439cb53 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -94,7 +94,7 @@ pub struct CopiedUpvar { } // different kinds of pointers: -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum PointerKind { OwnedPtr, GcPtr, @@ -104,26 +104,26 @@ pub enum PointerKind { // We use the term "interior" to mean "something reachable from the // base without a pointer dereference", e.g. a field -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum InteriorKind { InteriorField(FieldName), InteriorElement(ElementKind), } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum FieldName { NamedField(ast::Name), PositionalField(uint) } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum ElementKind { VecElement, StrElement, OtherElement, } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum MutabilityCategory { McImmutable, // Immutable. McDeclared, // Directly declared as mutable. diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 72967ff8195..8b7ade10990 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -105,7 +105,7 @@ enum PatternBindingMode { ArgumentIrrefutableMode, } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] enum Namespace { TypeNS, ValueNS diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 8ac885d183f..278a7ccbc7b 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -722,7 +722,7 @@ pub fn is_null(val: ValueRef) -> bool { } // Used to identify cached monomorphized functions and vtables -#[deriving(Eq,IterBytes)] +#[deriving(Eq,Hash)] pub enum mono_param_id { mono_precise(ty::t, Option<@~[mono_id]>), mono_any, @@ -732,7 +732,7 @@ pub enum mono_param_id { datum::RvalueMode), } -#[deriving(Eq,IterBytes)] +#[deriving(Eq,Hash)] pub enum MonoDataClass { MonoBits, // Anything not treated differently from arbitrary integer data MonoNonNull, // Non-null pointers (used for optional-pointer optimization) @@ -755,7 +755,7 @@ pub fn mono_data_classify(t: ty::t) -> MonoDataClass { } -#[deriving(Eq,IterBytes)] +#[deriving(Eq,Hash)] pub struct mono_id_ { def: ast::DefId, params: ~[mono_param_id] diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 329301efa5e..fe848c429ae 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -82,7 +82,7 @@ impl Drop for Rvalue { fn drop(&mut self) { } } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum RvalueMode { /// `val` is a pointer to the actual value (and thus has type *T) ByRef, diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index c7aedec4b48..8d88c084e99 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -33,9 +33,9 @@ use util::common::{indenter}; use std::cast; use std::cell::{Cell, RefCell}; use std::cmp; +use std::hash::{Hash, sip}; use std::ops; use std::rc::Rc; -use std::to_bytes; use std::to_str::ToStr; use std::vec; use collections::{HashMap, HashSet}; @@ -60,7 +60,7 @@ pub static INITIAL_DISCRIMINANT_VALUE: Disr = 0; // Data types -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub struct field { ident: ast::Ident, mt: mt @@ -122,20 +122,20 @@ pub struct Impl { methods: ~[@Method] } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct mt { ty: t, mutbl: ast::Mutability, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash, ToStr)] pub enum vstore { vstore_fixed(uint), vstore_uniq, vstore_slice(Region) } -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)] +#[deriving(Clone, Eq, Hash, Encodable, Decodable, ToStr)] pub enum TraitStore { UniqTraitStore, // ~Trait RegionTraitStore(Region), // &Trait @@ -149,7 +149,7 @@ pub struct field_ty { // Contains information needed to resolve types and (in the future) look up // the types of AST nodes. -#[deriving(Eq,IterBytes)] +#[deriving(Eq,Hash)] pub struct creader_cache_key { cnum: CrateNum, pos: uint, @@ -176,12 +176,10 @@ impl cmp::Eq for intern_key { } } -// NB: Do not replace this with #[deriving(IterBytes)], as above. (Figured -// this out the hard way.) -impl to_bytes::IterBytes for intern_key { - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { +impl Hash for intern_key { + fn hash(&self, s: &mut sip::SipState) { unsafe { - (*self.sty).iter_bytes(lsb0, f) + (*self.sty).hash(s) } } } @@ -416,14 +414,14 @@ pub fn type_has_regions(t: t) -> bool { } pub fn type_id(t: t) -> uint { get(t).id } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct BareFnTy { purity: ast::Purity, abis: AbiSet, sig: FnSig } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct ClosureTy { purity: ast::Purity, sigil: ast::Sigil, @@ -445,7 +443,7 @@ pub struct ClosureTy { * - `output` is the return type. * - `variadic` indicates whether this is a varidic function. (only true for foreign fns) */ -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct FnSig { binder_id: ast::NodeId, inputs: ~[t], @@ -453,14 +451,14 @@ pub struct FnSig { variadic: bool } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct param_ty { idx: uint, def_id: DefId } /// Representation of regions: -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr, Show)] +#[deriving(Clone, Eq, Hash, Encodable, Decodable, ToStr, Show)] pub enum Region { // Region bound in a type or fn declaration which will be // substituted 'early' -- that is, at the same time when type @@ -501,13 +499,13 @@ pub enum Region { * the original var id (that is, the root variable that is referenced * by the upvar) and the id of the closure expression. */ -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct UpvarId { var_id: ast::NodeId, closure_expr_id: ast::NodeId, } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub enum BorrowKind { /// Data must be immutable and is aliasable. ImmBorrow, @@ -620,13 +618,13 @@ impl Region { } } -#[deriving(Clone, Eq, TotalOrd, TotalEq, IterBytes, Encodable, Decodable, ToStr, Show)] +#[deriving(Clone, Eq, TotalOrd, TotalEq, Hash, Encodable, Decodable, ToStr, Show)] pub struct FreeRegion { scope_id: NodeId, bound_region: BoundRegion } -#[deriving(Clone, Eq, TotalEq, TotalOrd, IterBytes, Encodable, Decodable, ToStr, Show)] +#[deriving(Clone, Eq, TotalEq, TotalOrd, Hash, Encodable, Decodable, ToStr, Show)] pub enum BoundRegion { /// An anonymous region parameter for a given fn (&T) BrAnon(uint), @@ -645,7 +643,7 @@ pub enum BoundRegion { * Represents the values to use when substituting lifetime parameters. * If the value is `ErasedRegions`, then this subst is occurring during * trans, and all region parameters will be replaced with `ty::ReStatic`. */ -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub enum RegionSubsts { ErasedRegions, NonerasedRegions(OptVec) @@ -668,7 +666,7 @@ pub enum RegionSubsts { * - `self_ty` is the type to which `self` should be remapped, if any. The * `self` type is rather funny in that it can only appear on traits and is * always substituted away to the implementing type for a trait. */ -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct substs { self_ty: Option, tps: ~[t], @@ -723,7 +721,7 @@ mod primitives { // NB: If you change this, you'll probably want to change the corresponding // AST structure in libsyntax/ast.rs as well. -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub enum sty { ty_nil, ty_bot, @@ -758,7 +756,7 @@ pub enum sty { ty_unboxed_vec(mt), } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub struct TraitRef { def_id: DefId, substs: substs @@ -820,7 +818,7 @@ pub enum type_err { terr_variadic_mismatch(expected_found) } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub struct ParamBounds { builtin_bounds: BuiltinBounds, trait_bounds: ~[@TraitRef] @@ -828,7 +826,7 @@ pub struct ParamBounds { pub type BuiltinBounds = EnumSet; -#[deriving(Clone, Encodable, Eq, Decodable, IterBytes, ToStr)] +#[deriving(Clone, Encodable, Eq, Decodable, Hash, ToStr)] #[repr(uint)] pub enum BuiltinBound { BoundStatic, @@ -860,28 +858,28 @@ impl CLike for BuiltinBound { } } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct TyVid(uint); -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct IntVid(uint); -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub struct FloatVid(uint); -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, Show)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash, Show)] pub struct RegionVid { id: uint } -#[deriving(Clone, Eq, IterBytes)] +#[deriving(Clone, Eq, Hash)] pub enum InferTy { TyVar(TyVid), IntVar(IntVid), FloatVar(FloatVid) } -#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr, Show)] +#[deriving(Clone, Encodable, Decodable, Hash, ToStr, Show)] pub enum InferRegion { ReVar(RegionVid), ReSkolemized(uint, BoundRegion) @@ -4916,10 +4914,13 @@ pub fn trait_method_of_method(tcx: ctxt, /// Creates a hash of the type `t` which will be the same no matter what crate /// context it's calculated within. This is used by the `type_id` intrinsic. pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 { - use std::hash_old::{SipState, Streaming}; + use std::hash::{sip, Hash}; - let mut hash = SipState::new(0, 0); - let region = |_hash: &mut SipState, r: Region| { + let mut hash = sip::SipState::new(0, 0); + macro_rules! byte( ($b:expr) => { ($b as u8).hash(&mut hash) } ); + macro_rules! hash( ($e:expr) => { $e.hash(&mut hash) } ); + + let region = |_hash: &mut sip::SipState, r: Region| { match r { ReStatic => {} @@ -4933,130 +4934,127 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 { } } }; - let vstore = |hash: &mut SipState, v: vstore| { + let vstore = |hash: &mut sip::SipState, v: vstore| { match v { - vstore_fixed(_) => hash.input([0]), - vstore_uniq => hash.input([1]), + vstore_fixed(_) => 0u8.hash(hash), + vstore_uniq => 1u8.hash(hash), vstore_slice(r) => { - hash.input([3]); + 2u8.hash(hash); region(hash, r); } } }; - let did = |hash: &mut SipState, did: DefId| { + let did = |hash: &mut sip::SipState, did: DefId| { let h = if ast_util::is_local(did) { local_hash.clone() } else { tcx.sess.cstore.get_crate_hash(did.krate) }; - hash.input(h.as_bytes()); - iter(hash, &did.node); + h.as_bytes().hash(hash); + did.node.hash(hash); }; - let mt = |hash: &mut SipState, mt: mt| { - iter(hash, &mt.mutbl); + let mt = |hash: &mut sip::SipState, mt: mt| { + mt.mutbl.hash(hash); }; - fn iter(hash: &mut SipState, t: &T) { - t.iter_bytes(true, |bytes| { hash.input(bytes); true }); - } ty::walk_ty(t, |t| { match ty::get(t).sty { - ty_nil => hash.input([0]), - ty_bot => hash.input([1]), - ty_bool => hash.input([2]), - ty_char => hash.input([3]), + ty_nil => byte!(0), + ty_bot => byte!(1), + ty_bool => byte!(2), + ty_char => byte!(3), ty_int(i) => { - hash.input([4]); - iter(&mut hash, &i); + byte!(4); + hash!(i); } ty_uint(u) => { - hash.input([5]); - iter(&mut hash, &u); + byte!(5); + hash!(u); } ty_float(f) => { - hash.input([6]); - iter(&mut hash, &f); + byte!(6); + hash!(f); } ty_str(v) => { - hash.input([7]); - vstore(&mut hash, v); + byte!(7); + hash!(v); } ty_enum(d, _) => { - hash.input([8]); - did(&mut hash, d); + byte!(8); + hash!(d) } ty_box(_) => { - hash.input([9]); + byte!(9); } ty_uniq(_) => { - hash.input([10]); + byte!(10); } ty_vec(m, v) => { - hash.input([11]); + byte!(11); mt(&mut hash, m); vstore(&mut hash, v); } ty_ptr(m) => { - hash.input([12]); + byte!(12); mt(&mut hash, m); } ty_rptr(r, m) => { - hash.input([13]); + byte!(13); region(&mut hash, r); mt(&mut hash, m); } ty_bare_fn(ref b) => { - hash.input([14]); - iter(&mut hash, &b.purity); - iter(&mut hash, &b.abis); + byte!(14); + hash!(b.purity); + hash!(b.abis); } ty_closure(ref c) => { - hash.input([15]); - iter(&mut hash, &c.purity); - iter(&mut hash, &c.sigil); - iter(&mut hash, &c.onceness); - iter(&mut hash, &c.bounds); + byte!(15); + hash!(c.purity); + hash!(c.sigil); + hash!(c.onceness); + hash!(c.bounds); region(&mut hash, c.region); } ty_trait(d, _, store, m, bounds) => { - hash.input([17]); + byte!(17); did(&mut hash, d); match store { - UniqTraitStore => hash.input([0]), + UniqTraitStore => byte!(0), RegionTraitStore(r) => { - hash.input([1]); + byte!(1) region(&mut hash, r); } } - iter(&mut hash, &m); - iter(&mut hash, &bounds); + hash!(m); + hash!(bounds); } ty_struct(d, _) => { - hash.input([18]); + byte!(18); did(&mut hash, d); } ty_tup(ref inner) => { - hash.input([19]); - iter(&mut hash, &inner.len()); + byte!(19); + hash!(inner.len()); } ty_param(p) => { - hash.input([20]); - iter(&mut hash, &p.idx); + byte!(20); + hash!(p.idx); did(&mut hash, p.def_id); } ty_self(d) => { - hash.input([21]); + byte!(21); did(&mut hash, d); } ty_infer(_) => unreachable!(), - ty_err => hash.input([23]), + ty_err => byte!(23), ty_unboxed_vec(m) => { - hash.input([24]); + byte!(24); mt(&mut hash, m); } } }); - hash.result_u64() + hash.result() } impl Variance { diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index 98391436aa3..abf6df6124e 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -34,7 +34,7 @@ use syntax::opt_vec::OptVec; mod doc; -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] enum Constraint { ConstrainVarSubVar(RegionVid, RegionVid), ConstrainRegSubVar(Region, RegionVid), @@ -42,7 +42,7 @@ enum Constraint { ConstrainRegSubReg(Region, Region), } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] struct TwoRegions { a: Region, b: Region, diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 651d364dd1b..1ae36ab46aa 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -18,9 +18,9 @@ use str::OwnedStr; use container::Container; use cast; use fmt; +use hash::{Hash, sip}; use iter::Iterator; use vec::{ImmutableVector, MutableVector, Vector}; -use to_bytes::IterBytes; use option::{Option, Some, None}; /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero. @@ -314,10 +314,10 @@ impl IntoStr for ~[Ascii] { } } -impl IterBytes for Ascii { +impl Hash for Ascii { #[inline] - fn iter_bytes(&self, _lsb0: bool, f: |buf: &[u8]| -> bool) -> bool { - f([self.to_byte()]) + fn hash(&self, s: &mut sip::SipState) { + self.to_byte().hash(s) } } diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index f7c1986fca6..a55794b08fe 100644 --- a/src/libstd/fmt/mod.rs +++ b/src/libstd/fmt/mod.rs @@ -610,11 +610,6 @@ pub trait UpperExp { fn fmt(&self, &mut Formatter) -> Result; } // FIXME #11938 - UFCS would make us able call the above methods // directly Show::show(x, fmt). - -// FIXME(huonw's WIP): this is a intermediate state waiting for a -// snapshot (at the time of writing we're at 2014-01-20 b6400f9), to -// be able to make the `fmt` functions into normal methods and have -// `format!()` still work. macro_rules! uniform_fn_call_workaround { ($( $name: ident, $trait_: ident; )*) => { $( diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs index 555fe29bed0..6ad69d56181 100644 --- a/src/libstd/fmt/parse.rs +++ b/src/libstd/fmt/parse.rs @@ -121,7 +121,7 @@ pub enum Method<'a> { } /// A selector for what pluralization a plural method should take -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum PluralSelector { /// One of the plural keywords should be used Keyword(PluralKeyword), @@ -143,7 +143,7 @@ pub struct PluralArm<'a> { /// specially placed in the `Plural` variant of `Method` /// /// http://www.icu-project.org/apiref/icu4c/classicu_1_1PluralRules.html -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] #[allow(missing_doc)] pub enum PluralKeyword { Zero, One, Two, Few, Many diff --git a/src/libstd/hash_old.rs b/src/libstd/hash_old.rs deleted file mode 100644 index 07b16db95f8..00000000000 --- a/src/libstd/hash_old.rs +++ /dev/null @@ -1,510 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! - * Implementation of SipHash 2-4 - * - * See: http://131002.net/siphash/ - * - * Consider this as a main "general-purpose" hash for all hashtables: it - * runs at good speed (competitive with spooky and city) and permits - * strong _keyed_ hashing. Key your hashtables from a strong RNG, - * such as rand::rng. - * - * Although the SipHash algorithm is considered to be cryptographically - * strong, this implementation has not been reviewed for such purposes. - * As such, all cryptographic uses of this implementation are strongly - * discouraged. - */ - -#[allow(missing_doc)]; - -use container::Container; -use io::{Writer, IoResult}; -use iter::Iterator; -use option::{Some, None}; -use result::Ok; -use str::OwnedStr; -use to_bytes::IterBytes; -use vec::ImmutableVector; - -// Alias `SipState` to `State`. -pub use State = hash_old::SipState; - -/** - * Types that can meaningfully be hashed should implement this. - * - * Note that this trait is likely to change somewhat as it is - * closely related to `to_bytes::IterBytes` and in almost all - * cases presently the two are (and must be) used together. - * - * In general, most types only need to implement `IterBytes`, - * and the implementation of `Hash` below will take care of - * the rest. This is the recommended approach, since constructing - * good keyed hash functions is quite difficult. - */ -pub trait Hash { - /** - * Compute a "keyed" hash of the value implementing the trait, - * taking `k0` and `k1` as "keying" parameters that randomize or - * otherwise perturb the hash function in such a way that a - * hash table built using such "keyed hash functions" cannot - * be made to perform linearly by an attacker controlling the - * hashtable's contents. - * - * In practical terms, we implement this using the SipHash 2-4 - * function and require most types to only implement the - * IterBytes trait, that feeds SipHash. - */ - fn hash_keyed(&self, k0: u64, k1: u64) -> u64; - - #[inline] - fn hash(&self) -> u64 { self.hash_keyed(0,0) } -} - -/// Streaming hash-functions should implement this. -pub trait Streaming { - fn input(&mut self, &[u8]); - // These can be refactored some when we have default methods. - fn result_bytes(&mut self) -> ~[u8]; - fn result_str(&mut self) -> ~str; - fn result_u64(&mut self) -> u64; - fn reset(&mut self); -} - -impl Hash for A { - #[inline] - fn hash_keyed(&self, k0: u64, k1: u64) -> u64 { - let mut s = State::new(k0, k1); - self.iter_bytes(true, |bytes| { - s.input(bytes); - true - }); - s.result_u64() - } -} - -#[inline] -pub fn default_state() -> State { - State::new(0, 0) -} - -struct SipState { - k0: u64, - k1: u64, - length: uint, // how many bytes we've processed - v0: u64, // hash state - v1: u64, - v2: u64, - v3: u64, - tail: [u8, ..8], // unprocessed bytes - ntail: uint, // how many bytes in tail are valid -} - -impl SipState { - #[inline] - fn new(key0: u64, key1: u64) -> SipState { - let mut state = SipState { - k0: key0, - k1: key1, - length: 0, - v0: 0, - v1: 0, - v2: 0, - v3: 0, - tail: [ 0, 0, 0, 0, 0, 0, 0, 0 ], - ntail: 0, - }; - state.reset(); - state - } -} - -// sadly, these macro definitions can't appear later, -// because they're needed in the following defs; -// this design could be improved. - -macro_rules! u8to64_le ( - ($buf:expr, $i:expr) => - ($buf[0+$i] as u64 | - $buf[1+$i] as u64 << 8 | - $buf[2+$i] as u64 << 16 | - $buf[3+$i] as u64 << 24 | - $buf[4+$i] as u64 << 32 | - $buf[5+$i] as u64 << 40 | - $buf[6+$i] as u64 << 48 | - $buf[7+$i] as u64 << 56) -) - -macro_rules! rotl ( - ($x:expr, $b:expr) => - (($x << $b) | ($x >> (64 - $b))) -) - -macro_rules! compress ( - ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => - ({ - $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0; - $v0 = rotl!($v0, 32); - $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2; - $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0; - $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2; - $v2 = rotl!($v2, 32); - }) -) - - -impl Writer for SipState { - // Methods for io::writer - #[inline] - fn write(&mut self, msg: &[u8]) -> IoResult<()> { - let length = msg.len(); - self.length += length; - - let mut needed = 0u; - - if self.ntail != 0 { - needed = 8 - self.ntail; - - if length < needed { - let mut t = 0; - while t < length { - self.tail[self.ntail+t] = msg[t]; - t += 1; - } - self.ntail += length; - return Ok(()) - } - - let mut t = 0; - while t < needed { - self.tail[self.ntail+t] = msg[t]; - t += 1; - } - - let m = u8to64_le!(self.tail, 0); - - self.v3 ^= m; - compress!(self.v0, self.v1, self.v2, self.v3); - compress!(self.v0, self.v1, self.v2, self.v3); - self.v0 ^= m; - - self.ntail = 0; - } - - // Buffered tail is now flushed, process new input. - let len = length - needed; - let end = len & (!0x7); - let left = len & 0x7; - - let mut i = needed; - while i < end { - let mi = u8to64_le!(msg, i); - - self.v3 ^= mi; - compress!(self.v0, self.v1, self.v2, self.v3); - compress!(self.v0, self.v1, self.v2, self.v3); - self.v0 ^= mi; - - i += 8; - } - - let mut t = 0u; - while t < left { - self.tail[t] = msg[i+t]; - t += 1 - } - self.ntail = left; - Ok(()) - } -} - -impl Streaming for SipState { - #[inline] - fn input(&mut self, buf: &[u8]) { - self.write(buf).unwrap(); - } - - #[inline] - fn result_u64(&mut self) -> u64 { - let mut v0 = self.v0; - let mut v1 = self.v1; - let mut v2 = self.v2; - let mut v3 = self.v3; - - let mut b : u64 = (self.length as u64 & 0xff) << 56; - - if self.ntail > 0 { b |= self.tail[0] as u64 << 0; } - if self.ntail > 1 { b |= self.tail[1] as u64 << 8; } - if self.ntail > 2 { b |= self.tail[2] as u64 << 16; } - if self.ntail > 3 { b |= self.tail[3] as u64 << 24; } - if self.ntail > 4 { b |= self.tail[4] as u64 << 32; } - if self.ntail > 5 { b |= self.tail[5] as u64 << 40; } - if self.ntail > 6 { b |= self.tail[6] as u64 << 48; } - - v3 ^= b; - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - v0 ^= b; - - v2 ^= 0xff; - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - compress!(v0, v1, v2, v3); - - return v0 ^ v1 ^ v2 ^ v3; - } - - fn result_bytes(&mut self) -> ~[u8] { - let h = self.result_u64(); - ~[(h >> 0) as u8, - (h >> 8) as u8, - (h >> 16) as u8, - (h >> 24) as u8, - (h >> 32) as u8, - (h >> 40) as u8, - (h >> 48) as u8, - (h >> 56) as u8, - ] - } - - fn result_str(&mut self) -> ~str { - let r = self.result_bytes(); - let mut s = ~""; - for b in r.iter() { - s.push_str(format!("{:x}", *b)); - } - s - } - - #[inline] - fn reset(&mut self) { - self.length = 0; - self.v0 = self.k0 ^ 0x736f6d6570736575; - self.v1 = self.k1 ^ 0x646f72616e646f6d; - self.v2 = self.k0 ^ 0x6c7967656e657261; - self.v3 = self.k1 ^ 0x7465646279746573; - self.ntail = 0; - } -} - -#[cfg(test)] -mod tests { - use super::{Hash, Streaming, SipState}; - use iter::Iterator; - use num::ToStrRadix; - use option::Some; - use str::OwnedStr; - use to_bytes::IterBytes; - use vec::{Vector, OwnedVector, ImmutableVector}; - - // Hash just the bytes of the slice, without length prefix - struct Bytes<'a>(&'a [u8]); - impl<'a> IterBytes for Bytes<'a> { - fn iter_bytes(&self, _lsb0: bool, f: |&[u8]| -> bool) -> bool { - let Bytes(v) = *self; - f(v) - } - } - - #[test] - fn test_siphash() { - let vecs : [[u8, ..8], ..64] = [ - [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ], - [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ], - [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ], - [ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, ], - [ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, ], - [ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, ], - [ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, ], - [ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, ], - [ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, ], - [ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, ], - [ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, ], - [ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, ], - [ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, ], - [ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, ], - [ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, ], - [ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, ], - [ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, ], - [ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, ], - [ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, ], - [ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, ], - [ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, ], - [ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, ], - [ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, ], - [ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, ], - [ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, ], - [ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, ], - [ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, ], - [ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, ], - [ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, ], - [ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, ], - [ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, ], - [ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, ], - [ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, ], - [ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, ], - [ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, ], - [ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, ], - [ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, ], - [ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, ], - [ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, ], - [ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, ], - [ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, ], - [ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, ], - [ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, ], - [ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, ], - [ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, ], - [ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, ], - [ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, ], - [ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, ], - [ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, ], - [ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, ], - [ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, ], - [ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, ], - [ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, ], - [ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, ], - [ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, ], - [ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, ], - [ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, ], - [ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, ], - [ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, ], - [ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, ], - [ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, ], - [ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, ], - [ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, ], - [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ] - ]; - - let k0 = 0x_07_06_05_04_03_02_01_00_u64; - let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64; - let mut buf : ~[u8] = ~[]; - let mut t = 0; - let mut stream_inc = SipState::new(k0, k1); - let mut stream_full = SipState::new(k0, k1); - - fn to_hex_str(r: &[u8, ..8]) -> ~str { - let mut s = ~""; - for b in r.iter() { - s.push_str(format!("{:x}", *b)); - } - s - } - - while t < 64 { - debug!("siphash test {}", t); - let vec = u8to64_le!(vecs[t], 0); - let out = Bytes(buf.as_slice()).hash_keyed(k0, k1); - debug!("got {:?}, expected {:?}", out, vec); - assert_eq!(vec, out); - - stream_full.reset(); - stream_full.input(buf); - let f = stream_full.result_str(); - let i = stream_inc.result_str(); - let v = to_hex_str(&vecs[t]); - debug!("{}: ({}) => inc={} full={}", t, v, i, f); - - assert!(f == i && f == v); - - buf.push(t as u8); - stream_inc.input([t as u8]); - - t += 1; - } - } - - #[test] #[cfg(target_arch = "arm")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert!((val as u64).hash() != (val as uint).hash()); - assert_eq!((val as u32).hash(), (val as uint).hash()); - } - #[test] #[cfg(target_arch = "x86_64")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert_eq!((val as u64).hash(), (val as uint).hash()); - assert!((val as u32).hash() != (val as uint).hash()); - } - #[test] #[cfg(target_arch = "x86")] - fn test_hash_uint() { - let val = 0xdeadbeef_deadbeef_u64; - assert!((val as u64).hash() != (val as uint).hash()); - assert_eq!((val as u32).hash(), (val as uint).hash()); - } - - #[test] - fn test_hash_idempotent() { - let val64 = 0xdeadbeef_deadbeef_u64; - val64.hash() == val64.hash(); - let val32 = 0xdeadbeef_u32; - val32.hash() == val32.hash(); - } - - #[test] - fn test_hash_no_bytes_dropped_64() { - let val = 0xdeadbeef_deadbeef_u64; - - assert!(val.hash() != zero_byte(val, 0).hash()); - assert!(val.hash() != zero_byte(val, 1).hash()); - assert!(val.hash() != zero_byte(val, 2).hash()); - assert!(val.hash() != zero_byte(val, 3).hash()); - assert!(val.hash() != zero_byte(val, 4).hash()); - assert!(val.hash() != zero_byte(val, 5).hash()); - assert!(val.hash() != zero_byte(val, 6).hash()); - assert!(val.hash() != zero_byte(val, 7).hash()); - - fn zero_byte(val: u64, byte: uint) -> u64 { - assert!(byte < 8); - val & !(0xff << (byte * 8)) - } - } - - #[test] - fn test_hash_no_bytes_dropped_32() { - let val = 0xdeadbeef_u32; - - assert!(val.hash() != zero_byte(val, 0).hash()); - assert!(val.hash() != zero_byte(val, 1).hash()); - assert!(val.hash() != zero_byte(val, 2).hash()); - assert!(val.hash() != zero_byte(val, 3).hash()); - - fn zero_byte(val: u32, byte: uint) -> u32 { - assert!(byte < 4); - val & !(0xff << (byte * 8)) - } - } - - #[test] - fn test_float_hashes_differ() { - assert!(0.0.hash() != 1.0.hash()); - assert!(1.0.hash() != (-1.0).hash()); - } - - #[test] - fn test_float_hashes_of_zero() { - assert_eq!(0.0.hash(), (-0.0).hash()); - } - - #[test] - fn test_hash_no_concat_alias() { - let s = ("aa", "bb"); - let t = ("aabb", ""); - let u = ("a", "abb"); - - let v = (&[1u8], &[0u8, 0], &[0u8]); - let w = (&[1u8, 0, 0, 0], &[], &[]); - - assert!(v != w); - assert!(s.hash() != t.hash() && s.hash() != u.hash()); - assert!(v.hash() != w.hash()); - } -} diff --git a/src/libstd/intrinsics.rs b/src/libstd/intrinsics.rs index b386335a428..7c2db7688fd 100644 --- a/src/libstd/intrinsics.rs +++ b/src/libstd/intrinsics.rs @@ -444,7 +444,7 @@ extern "rust-intrinsic" { /// `TypeId` represents a globally unique identifier for a type #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and // middle/lang_items.rs -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] #[cfg(not(test))] pub struct TypeId { priv t: u64, diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index f042661117e..13ea552ab3b 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -14,12 +14,11 @@ use iter::Iterator; use option::{Option, None, Some}; use str::StrSlice; use to_str::ToStr; -use to_bytes::IterBytes; use vec::{MutableCloneableVector, ImmutableVector, MutableVector}; pub type Port = u16; -#[deriving(Eq, TotalEq, Clone, IterBytes)] +#[deriving(Eq, TotalEq, Clone, Hash)] pub enum IpAddr { Ipv4Addr(u8, u8, u8, u8), Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16) @@ -49,7 +48,7 @@ impl ToStr for IpAddr { } } -#[deriving(Eq, TotalEq, Clone, IterBytes)] +#[deriving(Eq, TotalEq, Clone, Hash)] pub struct SocketAddr { ip: IpAddr, port: Port, @@ -340,7 +339,6 @@ impl FromStr for SocketAddr { mod test { use prelude::*; use super::*; - use to_bytes::ToBytes; #[test] fn test_from_str_ipv4() { @@ -442,14 +440,4 @@ mod test { assert!(a1.to_str() == ~"::ffff:192.0.2.128" || a1.to_str() == ~"::FFFF:192.0.2.128"); assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), ~"8:9:a:b:c:d:e:f"); } - - #[test] - fn ipv4_addr_to_bytes() { - Ipv4Addr(123, 20, 12, 56).to_bytes(true); - } - - #[test] - fn socket_addr_to_bytes() { - SocketAddr { ip: Ipv4Addr(1, 2, 3, 4), port: 1234 }.to_bytes(true); - } } diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index 19aff4f70fe..32670fa7c2c 100644 --- a/src/libstd/io/signal.rs +++ b/src/libstd/io/signal.rs @@ -30,7 +30,7 @@ use rt::rtio::{IoFactory, LocalIo, RtioSignal}; use vec::{ImmutableVector, OwnedVector}; #[repr(int)] -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] pub enum Signum { /// Equivalent to SIGBREAK, delivered when the user presses Ctrl-Break. Break = 21i, diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 638f7b89469..2c81bcd4b0e 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -143,9 +143,7 @@ pub mod from_str; pub mod num; pub mod iter; pub mod to_str; -pub mod to_bytes; pub mod clone; -pub mod hash_old; pub mod hash; pub mod container; pub mod default; @@ -228,7 +226,6 @@ mod std { pub use os; pub use rt; pub use str; - pub use to_bytes; pub use to_str; pub use unstable; } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 9aaa86c4cfe..d1af612e0ec 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -15,11 +15,11 @@ use c_str::{CString, ToCStr}; use clone::Clone; use cmp::Eq; use from_str::FromStr; +use hash::{Hash, sip}; use iter::{AdditiveIterator, Extendable, Iterator, Map}; use option::{Option, None, Some}; use str; use str::Str; -use to_bytes::IterBytes; use vec; use vec::{CloneableVector, RevSplits, Splits, Vector, VectorVector, ImmutableEqVector, OwnedVector, ImmutableVector, OwnedCloneableVector}; @@ -88,10 +88,10 @@ impl ToCStr for Path { } } -impl IterBytes for Path { +impl Hash for Path { #[inline] - fn iter_bytes(&self, lsb0: bool, f: |buf: &[u8]| -> bool) -> bool { - self.repr.iter_bytes(lsb0, f) + fn hash(&self, s: &mut sip::SipState) { + self.repr.hash(s) } } diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 972b7d178a1..8902ab2edd7 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -17,11 +17,11 @@ use clone::Clone; use container::Container; use cmp::Eq; use from_str::FromStr; +use hash::{Hash, sip}; use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map}; use option::{Option, Some, None}; use str; use str::{CharSplits, OwnedStr, Str, StrVector, StrSlice}; -use to_bytes::IterBytes; use vec::{Vector, OwnedVector, ImmutableVector}; use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe}; @@ -112,10 +112,10 @@ impl ToCStr for Path { } } -impl IterBytes for Path { +impl Hash for Path { #[inline] - fn iter_bytes(&self, lsb0: bool, f: |&[u8]| -> bool) -> bool { - self.repr.iter_bytes(lsb0, f) + fn hash(&self, s: &mut sip::SipState) { + self.repr.hash(s) } } diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index 83ef85fc35b..ce746852dae 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -55,7 +55,6 @@ pub use path::{GenericPath, Path, PosixPath, WindowsPath}; pub use ptr::RawPtr; pub use io::{Buffer, Writer, Reader, Seek}; pub use str::{Str, StrVector, StrSlice, OwnedStr, IntoMaybeOwned}; -pub use to_bytes::IterBytes; pub use to_str::{ToStr, IntoStr}; pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4}; pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8}; diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 4d5eabbed10..4b03f478cd7 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -89,6 +89,7 @@ use clone::{Clone, DeepClone}; use cmp::{Eq, TotalEq, Ord, TotalOrd, Equiv, Ordering}; use container::{Container, Mutable}; use fmt; +use hash::{Hash, sip}; use iter::{Iterator, FromIterator, Extendable, range}; use iter::{Filter, AdditiveIterator, Map}; use iter::{Rev, DoubleEndedIterator, ExactSize}; @@ -103,7 +104,6 @@ use vec; use vec::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector}; use vec_ng::Vec; use default::Default; -use to_bytes::{IterBytes, Cb}; use raw::Repr; /* @@ -1356,13 +1356,10 @@ impl<'a> Default for MaybeOwned<'a> { fn default() -> MaybeOwned<'a> { Slice("") } } -impl<'a> IterBytes for MaybeOwned<'a> { +impl<'a> Hash for MaybeOwned<'a> { #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - match *self { - Slice(s) => s.iter_bytes(lsb0, f), - Owned(ref s) => s.iter_bytes(lsb0, f) - } + fn hash(&self, s: &mut sip::SipState) { + self.as_slice().hash(s) } } diff --git a/src/libstd/to_bytes.rs b/src/libstd/to_bytes.rs deleted file mode 100644 index 5518fa11684..00000000000 --- a/src/libstd/to_bytes.rs +++ /dev/null @@ -1,375 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! - -The `ToBytes` and `IterBytes` traits for converting to raw bytes - -*/ - -use cast; -use container::Container; -use iter::Iterator; -use option::{None, Option, Some}; -use rc::Rc; -use str::{Str, StrSlice}; -use vec::{Vector, ImmutableVector}; -use vec_ng::Vec; - -pub type Cb<'a> = 'a |buf: &[u8]| -> bool; - -/// -/// A trait to implement in order to make a type hashable; -/// This works in combination with the trait `std::hash::Hash`, and -/// may in the future be merged with that trait or otherwise -/// modified when default methods and trait inheritance are -/// completed. -/// -/// IterBytes should be implemented so that the extent of the -/// produced byte stream can be discovered, given the original -/// type. -/// For example, the IterBytes implementation for vectors emits -/// its length first, and enums should emit their discriminant. -/// -pub trait IterBytes { - /// Call the provided callback `f` one or more times with - /// byte-slices that should be used when computing a hash - /// value or otherwise "flattening" the structure into - /// a sequence of bytes. The `lsb0` parameter conveys - /// whether the caller is asking for little-endian bytes - /// (`true`) or big-endian (`false`); this should only be - /// relevant in implementations that represent a single - /// multi-byte datum such as a 32 bit integer or 64 bit - /// floating-point value. It can be safely ignored for - /// larger structured types as they are usually processed - /// left-to-right in declaration order, regardless of - /// underlying memory endianness. - /// - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool; -} - -impl IterBytes for bool { - #[inline] - fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool { - f([ - *self as u8 - ]) - } -} - -impl IterBytes for u8 { - #[inline] - fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool { - f([ - *self - ]) - } -} - -impl IterBytes for u16 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - if lsb0 { - f([ - *self as u8, - (*self >> 8) as u8 - ]) - } else { - f([ - (*self >> 8) as u8, - *self as u8 - ]) - } - } -} - -impl IterBytes for u32 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - if lsb0 { - f([ - *self as u8, - (*self >> 8) as u8, - (*self >> 16) as u8, - (*self >> 24) as u8, - ]) - } else { - f([ - (*self >> 24) as u8, - (*self >> 16) as u8, - (*self >> 8) as u8, - *self as u8 - ]) - } - } -} - -impl IterBytes for u64 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - if lsb0 { - f([ - *self as u8, - (*self >> 8) as u8, - (*self >> 16) as u8, - (*self >> 24) as u8, - (*self >> 32) as u8, - (*self >> 40) as u8, - (*self >> 48) as u8, - (*self >> 56) as u8 - ]) - } else { - f([ - (*self >> 56) as u8, - (*self >> 48) as u8, - (*self >> 40) as u8, - (*self >> 32) as u8, - (*self >> 24) as u8, - (*self >> 16) as u8, - (*self >> 8) as u8, - *self as u8 - ]) - } - } -} - -impl IterBytes for i8 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u8).iter_bytes(lsb0, f) - } -} - -impl IterBytes for i16 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u16).iter_bytes(lsb0, f) - } -} - -impl IterBytes for i32 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u32).iter_bytes(lsb0, f) - } -} - -impl IterBytes for i64 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u64).iter_bytes(lsb0, f) - } -} - -impl IterBytes for char { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u32).iter_bytes(lsb0, f) - } -} - -#[cfg(target_word_size = "32")] -impl IterBytes for uint { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u32).iter_bytes(lsb0, f) - } -} - -#[cfg(target_word_size = "64")] -impl IterBytes for uint { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as u64).iter_bytes(lsb0, f) - } -} - -impl IterBytes for int { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as uint).iter_bytes(lsb0, f) - } -} - -impl IterBytes for f32 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - let i: u32 = unsafe { - // 0.0 == -0.0 so they should also have the same hashcode - cast::transmute(if *self == -0.0 { 0.0 } else { *self }) - }; - i.iter_bytes(lsb0, f) - } -} - -impl IterBytes for f64 { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - let i: u64 = unsafe { - // 0.0 == -0.0 so they should also have the same hashcode - cast::transmute(if *self == -0.0 { 0.0 } else { *self }) - }; - i.iter_bytes(lsb0, f) - } -} - -impl<'a,A:IterBytes> IterBytes for &'a [A] { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - self.len().iter_bytes(lsb0, |b| f(b)) && - self.iter().advance(|elt| elt.iter_bytes(lsb0, |b| f(b))) - } -} - -impl IterBytes for (A, ) { - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - match *self { - (ref a, ) => a.iter_bytes(lsb0, |b| f(b)) - } - } -} - -macro_rules! iter_bytes_tuple( - ($($A:ident),+) => ( - impl<$($A: IterBytes),+> IterBytes for ($($A),+) { - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - match *self { - ($(ref $A),+) => { - $( - $A .iter_bytes(lsb0, |b| f(b)) - )&&+ - } - } - } - } - ) -) - -iter_bytes_tuple!(A, B) -iter_bytes_tuple!(A, B, C) -iter_bytes_tuple!(A, B, C, D) -iter_bytes_tuple!(A, B, C, D, E) -iter_bytes_tuple!(A, B, C, D, E, F) -iter_bytes_tuple!(A, B, C, D, E, F, G) -iter_bytes_tuple!(A, B, C, D, E, F, G, H) - -impl IterBytes for ~[A] { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - self.as_slice().iter_bytes(lsb0, f) - } -} - -impl IterBytes for Vec { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - self.as_slice().iter_bytes(lsb0, f) - } -} - -impl<'a> IterBytes for &'a str { - #[inline] - fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool { - // Terminate the string with a byte that does not appear in UTF-8 - f(self.as_bytes()) && f([0xFF]) - } -} - -impl IterBytes for ~str { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - self.as_slice().iter_bytes(lsb0, f) - } -} - -impl IterBytes for Option { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - match *self { - Some(ref a) => 0u8.iter_bytes(lsb0, |b| f(b)) && a.iter_bytes(lsb0, |b| f(b)), - None => 1u8.iter_bytes(lsb0, f) - } - } -} - -impl<'a,A:IterBytes> IterBytes for &'a A { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (**self).iter_bytes(lsb0, f) - } -} - -impl IterBytes for @A { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (**self).iter_bytes(lsb0, f) - } -} - -impl IterBytes for Rc { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - self.borrow().iter_bytes(lsb0, f) - } -} - -impl IterBytes for ~A { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (**self).iter_bytes(lsb0, f) - } -} - -// NB: raw-pointer IterBytes does _not_ dereference -// to the target; it just gives you the pointer-bytes. -impl IterBytes for *A { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as uint).iter_bytes(lsb0, f) - } -} - -impl IterBytes for *mut A { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool { - (*self as uint).iter_bytes(lsb0, f) - } -} - -/// A trait for converting a value to a list of bytes. -pub trait ToBytes { - /// Converts the current value to a list of bytes. This is equivalent to - /// invoking iter_bytes on a type and collecting all yielded values in an - /// array - fn to_bytes(&self, lsb0: bool) -> ~[u8]; -} - -impl ToBytes for A { - fn to_bytes(&self, lsb0: bool) -> ~[u8] { - use io::Writer; - - let mut m = ::io::MemWriter::new(); - self.iter_bytes(lsb0, |bytes| { - m.write(bytes).unwrap(); - true - }); - m.unwrap() - } -} - -#[cfg(test)] -mod test { - use super::*; - // just test to see if it compiles: - #[test] fn iterbytes_compiles () { - takes_iterbytes((3,4,5,false)); - } - fn takes_iterbytes(_x : T) {} -} diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 82e4d08d077..13725ef2473 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::to_bytes; +use std::hash::{Hash, sip}; #[deriving(Eq)] pub enum Os { OsWin32, OsMacos, OsLinux, OsAndroid, OsFreebsd, } @@ -64,7 +64,7 @@ enum AbiArchitecture { Archs(u32) // Multiple architectures (bitset) } -#[deriving(Clone, Eq, Encodable, Decodable)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct AbiSet { priv bits: u32 // each bit represents one of the abis below } @@ -265,15 +265,9 @@ impl AbiSet { } } -impl to_bytes::IterBytes for Abi { - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { - self.index().iter_bytes(lsb0, f) - } -} - -impl to_bytes::IterBytes for AbiSet { - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { - self.bits.iter_bytes(lsb0, f) +impl Hash for Abi { + fn hash(&self, s: &mut sip::SipState) { + self.index().hash(s) } } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index db1243b18bc..8bc3888b1d0 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -39,7 +39,7 @@ pub fn P(value: T) -> P { // table) and a SyntaxContext to track renaming and // macro expansion per Flatt et al., "Macros // That Work Together" -#[deriving(Clone, IterBytes, ToStr, TotalEq, TotalOrd, Show)] +#[deriving(Clone, Hash, ToStr, TotalEq, TotalOrd, Show)] pub struct Ident { name: Name, ctxt: SyntaxContext } impl Ident { @@ -101,7 +101,7 @@ pub struct SCTable { pub static EMPTY_CTXT : SyntaxContext = 0; pub static ILLEGAL_CTXT : SyntaxContext = 1; -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub enum SyntaxContext_ { EmptyCtxt, Mark (Mrk,SyntaxContext), @@ -140,7 +140,7 @@ impl Decodable for Ident { /// Function name (not all functions have names) pub type FnIdent = Option; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Lifetime { id: NodeId, span: Span, @@ -151,7 +151,7 @@ pub struct Lifetime { // for instance: std::cmp::Eq . It's represented // as a sequence of identifiers, along with a bunch // of supporting information. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Path { span: Span, /// A `::foo` path, is relative to the crate root rather than current @@ -163,7 +163,7 @@ pub struct Path { /// A segment of a path: an identifier, an optional lifetime, and a set of /// types. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct PathSegment { /// The identifier portion of this path segment. identifier: Ident, @@ -177,7 +177,7 @@ pub type CrateNum = u32; pub type NodeId = u32; -#[deriving(Clone, TotalEq, TotalOrd, Eq, Encodable, Decodable, IterBytes, ToStr, Show)] +#[deriving(Clone, TotalEq, TotalOrd, Eq, Encodable, Decodable, Hash, ToStr, Show)] pub struct DefId { krate: CrateNum, node: NodeId, @@ -197,13 +197,13 @@ pub static DUMMY_NODE_ID: NodeId = -1; // typeck::collect::compute_bounds matches these against // the "special" built-in traits (see middle::lang_items) and // detects Copy, Send, Send, and Freeze. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum TyParamBound { TraitTyParamBound(TraitRef), RegionTyParamBound } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct TyParam { ident: Ident, id: NodeId, @@ -211,7 +211,7 @@ pub struct TyParam { default: Option> } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Generics { lifetimes: OptVec, ty_params: OptVec, @@ -229,13 +229,13 @@ impl Generics { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum MethodProvenance { FromTrait(DefId), FromImpl(DefId), } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Def { DefFn(DefId, Purity), DefStaticMethod(/* method */ DefId, MethodProvenance, Purity), @@ -272,7 +272,7 @@ pub enum Def { DefMethod(DefId /* method */, Option /* trait */), } -#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)] +#[deriving(Clone, Eq, Hash, Encodable, Decodable, ToStr)] pub enum DefRegion { DefStaticRegion, DefEarlyBoundRegion(/* index */ uint, /* lifetime decl */ NodeId), @@ -284,7 +284,7 @@ pub enum DefRegion { // used to drive conditional compilation pub type CrateConfig = ~[@MetaItem]; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Crate { module: Mod, attrs: ~[Attribute], @@ -294,7 +294,7 @@ pub struct Crate { pub type MetaItem = Spanned; -#[deriving(Clone, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Encodable, Decodable, Hash)] pub enum MetaItem_ { MetaWord(InternedString), MetaList(InternedString, ~[@MetaItem]), @@ -326,7 +326,7 @@ impl Eq for MetaItem_ { } } -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub struct Block { view_items: ~[ViewItem], stmts: ~[@Stmt], @@ -336,26 +336,26 @@ pub struct Block { span: Span, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Pat { id: NodeId, node: Pat_, span: Span, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct FieldPat { ident: Ident, pat: @Pat, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum BindingMode { BindByRef(Mutability), BindByValue(Mutability), } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Pat_ { PatWild, PatWildMulti, @@ -380,13 +380,13 @@ pub enum Pat_ { PatVec(~[@Pat], Option<@Pat>, ~[@Pat]) } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Mutability { MutMutable, MutImmutable, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Sigil { BorrowedSigil, OwnedSigil, @@ -403,14 +403,14 @@ impl ToStr for Sigil { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum ExprVstore { ExprVstoreUniq, // ~[1,2,3,4] ExprVstoreSlice, // &[1,2,3,4] ExprVstoreMutSlice, // &mut [1,2,3,4] } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum BinOp { BiAdd, BiSub, @@ -432,7 +432,7 @@ pub enum BinOp { BiGt, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum UnOp { UnBox, UnUniq, @@ -443,7 +443,7 @@ pub enum UnOp { pub type Stmt = Spanned; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Stmt_ { // could be an item or a local (let) binding: StmtDecl(@Decl, NodeId), @@ -461,7 +461,7 @@ pub enum Stmt_ { // FIXME (pending discussion of #1697, #2178...): local should really be // a refinement on pat. /// Local represents a `let` statement, e.g., `let : = ;` -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub struct Local { ty: P, pat: @Pat, @@ -472,7 +472,7 @@ pub struct Local { pub type Decl = Spanned; -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub enum Decl_ { // a local (let) binding: DeclLocal(@Local), @@ -480,14 +480,14 @@ pub enum Decl_ { DeclItem(@Item), } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Arm { pats: ~[@Pat], guard: Option<@Expr>, body: P, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Field { ident: SpannedIdent, expr: @Expr, @@ -496,19 +496,19 @@ pub struct Field { pub type SpannedIdent = Spanned; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum BlockCheckMode { DefaultBlock, UnsafeBlock(UnsafeSource), } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum UnsafeSource { CompilerGenerated, UserProvided, } -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub struct Expr { id: NodeId, node: Expr_, @@ -528,7 +528,7 @@ impl Expr { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Expr_ { ExprVstore(@Expr, ExprVstore), // First expr is the place; second expr is the value. @@ -600,7 +600,7 @@ pub enum Expr_ { // else knows what to do with them, so you'll probably get a syntax // error. // -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] #[doc="For macro invocations; parsing is delegated to the macro"] pub enum TokenTree { // a single token @@ -674,7 +674,7 @@ pub enum TokenTree { // pub type Matcher = Spanned; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Matcher_ { // match one token MatchTok(::parse::token::Token), @@ -691,12 +691,12 @@ pub type Mac = Spanned; // is being invoked, and the vector of token-trees contains the source // of the macro invocation. // There's only one flavor, now, so this could presumably be simplified. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Mac_ { MacInvocTT(Path, ~[TokenTree], SyntaxContext), // new macro-invocation } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum StrStyle { CookedStr, RawStr(uint) @@ -704,7 +704,7 @@ pub enum StrStyle { pub type Lit = Spanned; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Lit_ { LitStr(InternedString, StrStyle), LitBinary(Rc<~[u8]>), @@ -720,20 +720,20 @@ pub enum Lit_ { // NB: If you change this, you'll probably want to change the corresponding // type structure in middle/ty.rs as well. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct MutTy { ty: P, mutbl: Mutability, } -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub struct TypeField { ident: Ident, mt: MutTy, span: Span, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct TypeMethod { ident: Ident, attrs: ~[Attribute], @@ -748,13 +748,13 @@ pub struct TypeMethod { // A trait method is either required (meaning it doesn't have an // implementation, just a signature) or provided (meaning it has a default // implementation). -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum TraitMethod { Required(TypeMethod), Provided(@Method), } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum IntTy { TyI, TyI8, @@ -769,7 +769,7 @@ impl ToStr for IntTy { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum UintTy { TyU, TyU8, @@ -784,7 +784,7 @@ impl ToStr for UintTy { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum FloatTy { TyF32, TyF64, @@ -797,7 +797,7 @@ impl ToStr for FloatTy { } // NB Eq method appears below. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Ty { id: NodeId, node: Ty_, @@ -805,7 +805,7 @@ pub struct Ty { } // Not represented directly in the AST, referred to by name through a ty_path. -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum PrimTy { TyInt(IntTy), TyUint(UintTy), @@ -815,7 +815,7 @@ pub enum PrimTy { TyChar } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Onceness { Once, Many @@ -830,7 +830,7 @@ impl ToStr for Onceness { } } -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub struct ClosureTy { sigil: Sigil, region: Option, @@ -845,7 +845,7 @@ pub struct ClosureTy { bounds: Option>, } -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable, Hash)] pub struct BareFnTy { purity: Purity, abis: AbiSet, @@ -853,7 +853,7 @@ pub struct BareFnTy { decl: P } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Ty_ { TyNil, TyBot, /* bottom type */ @@ -874,13 +874,13 @@ pub enum Ty_ { TyInfer, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum AsmDialect { AsmAtt, AsmIntel } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct InlineAsm { asm: InternedString, asm_str_style: StrStyle, @@ -892,7 +892,7 @@ pub struct InlineAsm { dialect: AsmDialect } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Arg { ty: P, pat: @Pat, @@ -919,7 +919,7 @@ impl Arg { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct FnDecl { inputs: ~[Arg], output: P, @@ -927,7 +927,7 @@ pub struct FnDecl { variadic: bool } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Purity { UnsafeFn, // declared with "unsafe fn" ImpureFn, // declared with "fn" @@ -944,14 +944,14 @@ impl ToStr for Purity { } } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum RetStyle { NoReturn, // functions with return type _|_ that always // raise an error or exit (i.e. never return to the caller) Return, // everything else } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum ExplicitSelf_ { SelfStatic, // no self SelfValue, // `self` @@ -961,7 +961,7 @@ pub enum ExplicitSelf_ { pub type ExplicitSelf = Spanned; -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub struct Method { ident: Ident, attrs: ~[Attribute], @@ -975,37 +975,37 @@ pub struct Method { vis: Visibility, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Mod { view_items: ~[ViewItem], items: ~[@Item], } -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub struct ForeignMod { abis: AbiSet, view_items: ~[ViewItem], items: ~[@ForeignItem], } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct VariantArg { ty: P, id: NodeId, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum VariantKind { TupleVariantKind(~[VariantArg]), StructVariantKind(@StructDef), } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct EnumDef { variants: ~[P], } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Variant_ { name: Ident, attrs: ~[Attribute], @@ -1017,7 +1017,7 @@ pub struct Variant_ { pub type Variant = Spanned; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct PathListIdent_ { name: Ident, id: NodeId, @@ -1027,7 +1027,7 @@ pub type PathListIdent = Spanned; pub type ViewPath = Spanned; -#[deriving(Eq, Encodable, Decodable, IterBytes)] +#[deriving(Eq, Encodable, Decodable, Hash)] pub enum ViewPath_ { // quux = foo::bar::baz @@ -1044,7 +1044,7 @@ pub enum ViewPath_ { ViewPathList(Path, ~[PathListIdent], NodeId) } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct ViewItem { node: ViewItem_, attrs: ~[Attribute], @@ -1052,7 +1052,7 @@ pub struct ViewItem { span: Span, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum ViewItem_ { // ident: name used to refer to this crate in the code // optional (InternedString,StrStyle): if present, this is a location @@ -1068,14 +1068,14 @@ pub type Attribute = Spanned; // Distinguishes between Attributes that decorate items and Attributes that // are contained as statements within items. These two cases need to be // distinguished for pretty-printing. -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub enum AttrStyle { AttrOuter, AttrInner, } // doc-comments are promoted to attributes that have is_sugared_doc = true -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub struct Attribute_ { style: AttrStyle, value: @MetaItem, @@ -1089,13 +1089,13 @@ pub struct Attribute_ { If this impl is an ItemImpl, the impl_id is redundant (it could be the same as the impl's node id). */ -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub struct TraitRef { path: Path, ref_id: NodeId, } -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub enum Visibility { Public, Private, @@ -1111,7 +1111,7 @@ impl Visibility { } } -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub struct StructField_ { kind: StructFieldKind, id: NodeId, @@ -1121,13 +1121,13 @@ pub struct StructField_ { pub type StructField = Spanned; -#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable,Hash)] pub enum StructFieldKind { NamedField(Ident, Visibility), UnnamedField // element of a tuple-like struct } -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub struct StructDef { fields: ~[StructField], /* fields, not including ctor */ /* ID of the constructor. This is only used for tuple- or enum-like @@ -1139,7 +1139,7 @@ pub struct StructDef { FIXME (#3300): Should allow items to be anonymous. Right now we just use dummy names for anon items. */ -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Item { ident: Ident, attrs: ~[Attribute], @@ -1149,7 +1149,7 @@ pub struct Item { span: Span, } -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub enum Item_ { ItemStatic(P, Mutability, @Expr), ItemFn(P, Purity, AbiSet, Generics, P), @@ -1167,7 +1167,7 @@ pub enum Item_ { ItemMac(Mac), } -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub struct ForeignItem { ident: Ident, attrs: ~[Attribute], @@ -1177,7 +1177,7 @@ pub struct ForeignItem { vis: Visibility, } -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub enum ForeignItem_ { ForeignItemFn(P, Generics), ForeignItemStatic(P, /* is_mutbl */ bool), @@ -1186,7 +1186,7 @@ pub enum ForeignItem_ { // The data we save and restore about an inlined item or method. This is not // part of the AST that we parse from a file, but it becomes part of the tree // that we trans. -#[deriving(Eq, Encodable, Decodable,IterBytes)] +#[deriving(Eq, Encodable, Decodable,Hash)] pub enum InlinedItem { IIItem(@Item), IIMethod(DefId /* impl id */, bool /* is provided */, @Method), diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 486a25fa775..83700e390cb 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -32,13 +32,13 @@ pub trait Pos { /// A byte offset. Keep this small (currently 32-bits), as AST contains /// a lot of them. -#[deriving(Clone, Eq, IterBytes, Ord)] +#[deriving(Clone, Eq, Hash, Ord)] pub struct BytePos(u32); /// A character offset. Because of multibyte utf8 characters, a byte offset /// is not equivalent to a character offset. The CodeMap will convert BytePos /// values to CharPos values as necessary. -#[deriving(Eq,IterBytes, Ord)] +#[deriving(Eq,Hash, Ord)] pub struct CharPos(uint); // FIXME: Lots of boilerplate in these impls, but so far my attempts to fix @@ -84,7 +84,7 @@ are *absolute* positions from the beginning of the codemap, not positions relative to FileMaps. Methods on the CodeMap can be used to relate spans back to the original source. */ -#[deriving(Clone, IterBytes)] +#[deriving(Clone, Hash)] pub struct Span { lo: BytePos, hi: BytePos, @@ -93,7 +93,7 @@ pub struct Span { pub static DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_info: None }; -#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Eq, Encodable, Decodable, Hash)] pub struct Spanned { node: T, span: Span, @@ -160,7 +160,7 @@ pub struct LocWithOpt { pub struct FileMapAndLine {fm: @FileMap, line: uint} pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos} -#[deriving(Clone, IterBytes)] +#[deriving(Clone, Hash)] pub enum MacroFormat { // e.g. #[deriving(...)] MacroAttribute, @@ -168,7 +168,7 @@ pub enum MacroFormat { MacroBang } -#[deriving(Clone, IterBytes)] +#[deriving(Clone, Hash)] pub struct NameAndSpan { name: ~str, // the format with which the macro was invoked. @@ -177,7 +177,7 @@ pub struct NameAndSpan { } /// Extra information for tracking macro expansion of spans -#[deriving(IterBytes)] +#[deriving(Hash)] pub struct ExpnInfo { call_site: Span, callee: NameAndSpan diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs deleted file mode 100644 index b39e22bc1ad..00000000000 --- a/src/libsyntax/ext/deriving/iter_bytes.rs +++ /dev/null @@ -1,100 +0,0 @@ -// Copyright 2013 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use ast::{MetaItem, Item, Expr, BiAnd}; -use codemap::Span; -use ext::base::ExtCtxt; -use ext::build::AstBuilder; -use ext::deriving::generic::*; - - -pub fn expand_deriving_iter_bytes(cx: &mut ExtCtxt, - span: Span, - mitem: @MetaItem, - item: @Item, - push: |@Item|) { - let trait_def = TraitDef { - span: span, - attributes: ~[], - path: Path::new(~["std", "to_bytes", "IterBytes"]), - additional_bounds: ~[], - generics: LifetimeBounds::empty(), - methods: ~[ - MethodDef { - name: "iter_bytes", - generics: LifetimeBounds::empty(), - explicit_self: borrowed_explicit_self(), - args: ~[ - Literal(Path::new(~["bool"])), - Literal(Path::new(~["std", "to_bytes", "Cb"])) - ], - ret_ty: Literal(Path::new(~["bool"])), - inline: true, - const_nonmatching: false, - combine_substructure: iter_bytes_substructure - } - ] - }; - - trait_def.expand(cx, mitem, item, push) -} - -fn iter_bytes_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr { - let (lsb0, f)= match substr.nonself_args { - [l, f] => (l, f), - _ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(IterBytes)`") - }; - // Build the "explicitly borrowed" stack closure, "|_buf| f(_buf)". - let blk_arg = cx.ident_of("_buf"); - let borrowed_f = - cx.lambda_expr_1(trait_span, - cx.expr_call(trait_span, f, ~[cx.expr_ident(trait_span, blk_arg)]), - blk_arg); - - let iter_bytes_ident = substr.method_ident; - let call_iterbytes = |span, thing_expr| { - cx.expr_method_call(span, - thing_expr, - iter_bytes_ident, - ~[lsb0, borrowed_f]) - }; - let mut exprs = ~[]; - let fields; - match *substr.fields { - Struct(ref fs) => { - fields = fs - } - EnumMatching(index, ref variant, ref fs) => { - // Determine the discriminant. We will feed this value to the byte - // iteration function. - let discriminant = match variant.node.disr_expr { - Some(d)=> d, - None => cx.expr_uint(trait_span, index) - }; - - exprs.push(call_iterbytes(trait_span, discriminant)); - - fields = fs; - } - _ => cx.span_bug(trait_span, "impossible substructure in `deriving(IterBytes)`") - } - - for &FieldInfo { self_, span, .. } in fields.iter() { - exprs.push(call_iterbytes(span, self_)); - } - - if exprs.len() == 0 { - cx.span_bug(trait_span, "#[deriving(IterBytes)] needs at least one field"); - } - - exprs.slice(1, exprs.len()).iter().fold(exprs[0], |prev, me| { - cx.expr_binary(trait_span, BiAnd, prev, *me) - }) -} diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index 31ee99fbd26..95b9a45b9fc 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -23,7 +23,6 @@ use ext::base::ExtCtxt; use codemap::Span; pub mod clone; -pub mod iter_bytes; pub mod encodable; pub mod decodable; pub mod hash; @@ -74,7 +73,6 @@ pub fn expand_meta_deriving(cx: &mut ExtCtxt, "Clone" => expand!(clone::expand_deriving_clone), "DeepClone" => expand!(clone::expand_deriving_deep_clone), - "IterBytes" => expand!(iter_bytes::expand_deriving_iter_bytes), "Hash" => expand!(hash::expand_deriving_hash), "Encodable" => expand!(encodable::expand_deriving_encodable), diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs index 21f05fa684a..3abd411a003 100644 --- a/src/libsyntax/opt_vec.rs +++ b/src/libsyntax/opt_vec.rs @@ -17,7 +17,7 @@ use std::vec; -#[deriving(Clone, Encodable, Decodable, IterBytes)] +#[deriving(Clone, Encodable, Decodable, Hash)] pub enum OptVec { Empty, Vec(~[T]) diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index accffd374a9..393282dd063 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -22,10 +22,8 @@ use codemap::{Span, respan}; use parse::parser::Parser; use parse::token; -use std::to_bytes; - /// The specific types of unsupported syntax -#[deriving(Eq)] +#[deriving(Eq, Hash)] pub enum ObsoleteSyntax { ObsoleteSwap, ObsoleteUnsafeBlock, @@ -46,13 +44,6 @@ pub enum ObsoleteSyntax { ObsoleteManagedVec, } -impl to_bytes::IterBytes for ObsoleteSyntax { - #[inline] - fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { - (*self as uint).iter_bytes(lsb0, f) - } -} - pub trait ParserObsoleteMethods { /// Reports an obsolete syntax non-fatal error. fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax); diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index b264e8d7467..a2f3b65f06e 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -23,7 +23,7 @@ use std::local_data; use std::path::BytesContainer; #[allow(non_camel_case_types)] -#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)] +#[deriving(Clone, Encodable, Decodable, Eq, Hash)] pub enum BinOp { PLUS, MINUS, @@ -38,7 +38,7 @@ pub enum BinOp { } #[allow(non_camel_case_types)] -#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)] +#[deriving(Clone, Encodable, Decodable, Eq, Hash)] pub enum Token { /* Expression-operator symbols. */ EQ, @@ -102,7 +102,7 @@ pub enum Token { EOF, } -#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)] +#[deriving(Clone, Encodable, Decodable, Eq, Hash)] /// For interpolation during macro expansion. pub enum Nonterminal { NtItem(@ast::Item), @@ -536,7 +536,7 @@ pub fn get_ident_interner() -> @IdentInterner { /// destroyed. In particular, they must not access string contents. This can /// be fixed in the future by just leaking all strings until task death /// somehow. -#[deriving(Clone, Eq, IterBytes, Ord, TotalEq, TotalOrd)] +#[deriving(Clone, Eq, Hash, Ord, TotalEq, TotalOrd)] pub struct InternedString { priv string: RcStr, } diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 44b366c9890..fa21924bbb9 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -18,7 +18,7 @@ use collections::HashMap; use std::cast; use std::cell::RefCell; use std::cmp::Equiv; -use std::hash_old::Hash; +use std::hash::Hash; use std::rc::Rc; pub struct Interner { @@ -27,7 +27,7 @@ pub struct Interner { } // when traits can extend traits, we should extend index to get [] -impl Interner { +impl Interner { pub fn new() -> Interner { Interner { map: RefCell::new(HashMap::new()), @@ -75,7 +75,7 @@ impl Interner { vect.get().len() } - pub fn find_equiv>(&self, val: &Q) + pub fn find_equiv>(&self, val: &Q) -> Option { let map = self.map.borrow(); match map.get().find_equiv(val) { @@ -85,7 +85,7 @@ impl Interner { } } -#[deriving(Clone, Eq, IterBytes, Ord)] +#[deriving(Clone, Eq, Hash, Ord)] pub struct RcStr { priv string: Rc<~str>, } @@ -207,7 +207,7 @@ impl StrInterner { vect.get().len() } - pub fn find_equiv>(&self, val: &Q) + pub fn find_equiv>(&self, val: &Q) -> Option { let map = self.map.borrow(); match map.get().find_equiv(val) { diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs index e4053e3bc38..dec27719beb 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -74,7 +74,7 @@ use std::rand; use std::rand::Rng; use std::cmp::Eq; use std::cast::{transmute,transmute_copy}; -use std::to_bytes::{IterBytes, Cb}; +use std::hash::{Hash, sip}; use serialize::{Encoder, Encodable, Decoder, Decodable}; @@ -114,9 +114,9 @@ pub struct Uuid { /// The 128-bit number stored in 16 bytes bytes: UuidBytes } -impl IterBytes for Uuid { - fn iter_bytes(&self, _: bool, f: Cb) -> bool { - f(self.bytes.slice_from(0)) +impl Hash for Uuid { + fn hash(&self, s: &mut sip::SipState) { + self.bytes.slice_from(0).hash(s) } } diff --git a/src/snapshots.txt b/src/snapshots.txt index 02a43cabe6f..47243320b6e 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,11 @@ +S 2014-02-22 4995a85 + freebsd-x86_64 0d8e2577d4b626cd8a5d9c29f0f91a4452bc1621 + linux-i386 afadce8cba1098b1b9ae1e53a649c1515cd26e3c + linux-x86_64 da512f607f63c4ea735d58e7fd01d44456569ca1 + macos-i386 5ea768930449b86146039da1336db7a87d599a49 + macos-x86_64 766ce886cc2716c336cceb51cccff760a6a22a38 + winnt-i386 06d14256eba9838afab4bb6f6ea857056f2d13c5 + S 2014-02-20 1366e04 freebsd-x86_64 f26a4fd99f824db7cf3b323389d560b90f6f16a7 linux-i386 26fd77a81ceaeff6916895bfb6b2bbaf4e19f21b diff --git a/src/test/run-pass/deriving-global.rs b/src/test/run-pass/deriving-global.rs index 544a8c2b00a..ffca06dc628 100644 --- a/src/test/run-pass/deriving-global.rs +++ b/src/test/run-pass/deriving-global.rs @@ -27,21 +27,18 @@ mod submod { // function calls, then being in a submodule will (correctly) // cause errors about unrecognised module `std` (or `extra`) #[deriving(Eq, Ord, TotalEq, TotalOrd, - IterBytes, Clone, DeepClone, ToStr, Rand, Encodable, Decodable)] enum A { A1(uint), A2(int) } #[deriving(Eq, Ord, TotalEq, TotalOrd, - IterBytes, Clone, DeepClone, ToStr, Rand, Encodable, Decodable)] struct B { x: uint, y: int } #[deriving(Eq, Ord, TotalEq, TotalOrd, - IterBytes, Clone, DeepClone, ToStr, Rand, Encodable, Decodable)] diff --git a/src/test/run-pass/deriving-meta-multiple.rs b/src/test/run-pass/deriving-meta-multiple.rs index 49bf101954b..58ec8e35281 100644 --- a/src/test/run-pass/deriving-meta-multiple.rs +++ b/src/test/run-pass/deriving-meta-multiple.rs @@ -10,11 +10,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::hash_old::Hash; - #[deriving(Eq)] #[deriving(Clone)] -#[deriving(IterBytes)] struct Foo { bar: uint, baz: int @@ -25,5 +22,4 @@ pub fn main() { a == a; // check for Eq impl w/o testing its correctness a.clone(); // check for Clone impl w/o testing its correctness - a.hash(); // check for IterBytes impl w/o testing its correctness } diff --git a/src/test/run-pass/deriving-meta.rs b/src/test/run-pass/deriving-meta.rs index 93193fc9d65..7f31aa586cc 100644 --- a/src/test/run-pass/deriving-meta.rs +++ b/src/test/run-pass/deriving-meta.rs @@ -10,9 +10,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::hash_old::Hash; - -#[deriving(Eq, Clone, IterBytes)] +#[deriving(Eq, Clone)] struct Foo { bar: uint, baz: int @@ -23,5 +21,4 @@ pub fn main() { a == a; // check for Eq impl w/o testing its correctness a.clone(); // check for Clone impl w/o testing its correctness - a.hash(); // check for IterBytes impl w/o testing its correctness } diff --git a/src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs b/src/test/run-pass/deriving-via-extension-hash-enum.rs similarity index 92% rename from src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs rename to src/test/run-pass/deriving-via-extension-hash-enum.rs index f95b7650991..fed10567a19 100644 --- a/src/test/run-pass/deriving-via-extension-iter-bytes-enum.rs +++ b/src/test/run-pass/deriving-via-extension-hash-enum.rs @@ -10,13 +10,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(IterBytes)] +#[deriving(Hash)] enum Foo { Bar(int, char), Baz(char, int) } -#[deriving(IterBytes)] +#[deriving(Hash)] enum A { B, C, diff --git a/src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs b/src/test/run-pass/deriving-via-extension-hash-struct.rs similarity index 96% rename from src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs rename to src/test/run-pass/deriving-via-extension-hash-struct.rs index 310421bc350..57c13a504d3 100644 --- a/src/test/run-pass/deriving-via-extension-iter-bytes-struct.rs +++ b/src/test/run-pass/deriving-via-extension-hash-struct.rs @@ -10,7 +10,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(IterBytes)] +#[deriving(Hash)] struct Foo { x: int, y: int, diff --git a/src/test/run-pass/deriving-via-extension-type-params.rs b/src/test/run-pass/deriving-via-extension-type-params.rs index 110f0918c02..c483816099d 100644 --- a/src/test/run-pass/deriving-via-extension-type-params.rs +++ b/src/test/run-pass/deriving-via-extension-type-params.rs @@ -11,7 +11,7 @@ // except according to those terms. #[deriving(Eq)] -#[deriving(IterBytes)] +#[deriving(Hash)] struct Foo { x: int, y: T, diff --git a/src/test/run-pass/regions-mock-tcx.rs b/src/test/run-pass/regions-mock-tcx.rs index 6dafd81a018..1a29bb75f91 100644 --- a/src/test/run-pass/regions-mock-tcx.rs +++ b/src/test/run-pass/regions-mock-tcx.rs @@ -85,7 +85,7 @@ impl<'tcx,'ast> TypeContext<'tcx, 'ast> { } } -#[deriving(Eq, IterBytes)] +#[deriving(Eq, Hash)] struct NodeId { id: uint } diff --git a/src/test/run-pass/typeid-intrinsic.rs b/src/test/run-pass/typeid-intrinsic.rs index b8356cc0e44..c874fbb7a8b 100644 --- a/src/test/run-pass/typeid-intrinsic.rs +++ b/src/test/run-pass/typeid-intrinsic.rs @@ -15,7 +15,7 @@ extern crate other1 = "typeid-intrinsic"; extern crate other2 = "typeid-intrinsic2"; -use std::hash_old::Hash; +use std::hash; use std::intrinsics; use std::intrinsics::TypeId; @@ -71,5 +71,5 @@ pub fn main() { // check it has a hash let (a, b) = (TypeId::of::(), TypeId::of::()); - assert_eq!(a.hash(), b.hash()); + assert_eq!(hash::hash(&a), hash::hash(&b)); }