nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-24 15:54:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

auto merge of #12522 : erickt/rust/hash, r=alexcrichton

Browse Source 
This patch series does a couple things:

* replaces manual `Hash` implementations with `#[deriving(Hash)]`
* adds `Hash` back to `std::prelude`
* minor cleanup of whitespace and variable names.
This commit is contained in:
bors 2014-02-25 06:41:36 -08:00
commit 25d68366b7
14 changed files with 68 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libcollections/hashmap.rs
View File

@ -98,7 +98,7 @@ fn resize_at(capacity: uint) -> uint {
(capacity * 3) / 4
}
impl<K:Hash + Eq,V> HashMap<K, V> {
impl<K:Hash + Eq, V> HashMap<K, V> {
#[inline]
fn to_bucket(&self, h: uint) -> uint {
// A good hash function with entropy spread over all of the

7
src/librustc/middle/trans/common.rs
View File

@ -722,7 +722,7 @@ pub fn is_null(val: ValueRef) -> bool {
}
// Used to identify cached monomorphized functions and vtables
#[deriving(Eq,Hash)]
#[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,Hash)]
#[deriving(Eq, Hash)]
pub enum MonoDataClass {
MonoBits, // Anything not treated differently from arbitrary integer data
MonoNonNull, // Non-null pointers (used for optional-pointer optimization)
@ -754,8 +754,7 @@ pub fn mono_data_classify(t: ty::t) -> MonoDataClass {
}
}
#[deriving(Eq,Hash)]
#[deriving(Eq, Hash)]
pub struct mono_id_ {
def: ast::DefId,
params: ~[mono_param_id]

58
src/librustc/middle/ty.rs
View File

@ -150,7 +150,7 @@ pub struct field_ty {
// Contains information needed to resolve types and (in the future) look up
// the types of AST nodes.
#[deriving(Eq,Hash)]
#[deriving(Eq, Hash)]
pub struct creader_cache_key {
cnum: CrateNum,
pos: uint,
@ -4926,13 +4926,11 @@ 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::{sip, Hash};
let mut state = sip::SipState::new(0, 0);
macro_rules! byte( ($b:expr) => { ($b as u8).hash(&mut state) } );
macro_rules! hash( ($e:expr) => { $e.hash(&mut state) } );
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| {
let region = |_state: &mut sip::SipState, r: Region| {
match r {
ReStatic => {}
@ -4946,27 +4944,27 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
}
}
};
let vstore = |hash: &mut sip::SipState, v: vstore| {
let vstore = |state: &mut sip::SipState, v: vstore| {
match v {
vstore_fixed(_) => 0u8.hash(hash),
vstore_uniq => 1u8.hash(hash),
vstore_fixed(_) => 0u8.hash(state),
vstore_uniq => 1u8.hash(state),
vstore_slice(r) => {
2u8.hash(hash);
region(hash, r);
2u8.hash(state);
region(state, r);
}
}
};
let did = |hash: &mut sip::SipState, did: DefId| {
let did = |state: &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)
};
h.as_bytes().hash(hash);
did.node.hash(hash);
h.as_bytes().hash(state);
did.node.hash(state);
};
let mt = |hash: &mut sip::SipState, mt: mt| {
mt.mutbl.hash(hash);
let mt = |state: &mut sip::SipState, mt: mt| {
mt.mutbl.hash(state);
};
ty::walk_ty(t, |t| {
match ty::get(t).sty {
@ -5002,17 +5000,17 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
}
ty_vec(m, v) => {
byte!(11);
mt(&mut hash, m);
vstore(&mut hash, v);
mt(&mut state, m);
vstore(&mut state, v);
}
ty_ptr(m) => {
byte!(12);
mt(&mut hash, m);
mt(&mut state, m);
}
ty_rptr(r, m) => {
byte!(13);
region(&mut hash, r);
mt(&mut hash, m);
region(&mut state, r);
mt(&mut state, m);
}
ty_bare_fn(ref b) => {
byte!(14);
@ -5025,16 +5023,16 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
hash!(c.sigil);
hash!(c.onceness);
hash!(c.bounds);
region(&mut hash, c.region);
region(&mut state, c.region);
}
ty_trait(d, _, store, m, bounds) => {
byte!(17);
did(&mut hash, d);
did(&mut state, d);
match store {
UniqTraitStore => byte!(0),
RegionTraitStore(r) => {
byte!(1)
region(&mut hash, r);
region(&mut state, r);
}
}
hash!(m);
@ -5042,7 +5040,7 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
}
ty_struct(d, _) => {
byte!(18);
did(&mut hash, d);
did(&mut state, d);
}
ty_tup(ref inner) => {
byte!(19);
@ -5051,22 +5049,22 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
ty_param(p) => {
byte!(20);
hash!(p.idx);
did(&mut hash, p.def_id);
did(&mut state, p.def_id);
}
ty_self(d) => {
byte!(21);
did(&mut hash, d);
did(&mut state, d);
}
ty_infer(_) => unreachable!(),
ty_err => byte!(23),
ty_unboxed_vec(m) => {
byte!(24);
mt(&mut hash, m);
mt(&mut state, m);
}
}
});
hash.result()
state.result()
}
impl Variance {

10
src/libstd/ascii.rs
View File

@ -18,13 +18,12 @@ use str::OwnedStr;
use container::Container;
use cast;
use fmt;
use hash::{Hash, sip};
use iter::Iterator;
use vec::{ImmutableVector, MutableVector, Vector};
use option::{Option, Some, None};
/// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq)]
#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq, Hash)]
pub struct Ascii { priv chr: u8 }
impl Ascii {
@ -306,13 +305,6 @@ impl IntoStr for ~[Ascii] {
}
}
impl Hash for Ascii {
#[inline]
fn hash(&self, s: &mut sip::SipState) {
self.to_byte().hash(s)
}
}
/// Trait to convert to an owned byte array by consuming self
pub trait IntoBytes {
/// Converts to an owned byte array by consuming self

1
src/libstd/io/net/ip.rs
View File

@ -55,7 +55,6 @@ pub struct SocketAddr {
port: Port,
}
impl fmt::Show for SocketAddr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.ip {

1
src/libstd/lib.rs
View File

@ -151,7 +151,6 @@ pub mod container;
pub mod default;
pub mod any;
/* Common data structures */
pub mod option;

9
src/libsyntax/abi.rs
View File

@ -8,14 +8,13 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::hash::{Hash, sip};
use std::fmt;
use std::fmt::Show;
#[deriving(Eq)]
pub enum Os { OsWin32, OsMacos, OsLinux, OsAndroid, OsFreebsd, }
#[deriving(Eq)]
#[deriving(Eq, Hash)]
pub enum Abi {
// NB: This ordering MUST match the AbiDatas array below.
// (This is ensured by the test indices_are_correct().)
@ -267,12 +266,6 @@ impl AbiSet {
}
}
impl Hash for Abi {
fn hash(&self, s: &mut sip::SipState) {
self.index().hash(s)
}
}
impl fmt::Show for Abi {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.data().name.fmt(f)

38
src/libsyntax/ast.rs
View File

@ -107,7 +107,7 @@ pub struct SCTable {
pub static EMPTY_CTXT : SyntaxContext = 0;
pub static ILLEGAL_CTXT : SyntaxContext = 1;
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub enum SyntaxContext_ {
EmptyCtxt,
Mark (Mrk,SyntaxContext),
@ -332,7 +332,7 @@ impl Eq for MetaItem_ {
}
}
#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Block {
view_items: ~[ViewItem],
stmts: ~[@Stmt],
@ -467,7 +467,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 <pat>:<ty> = <expr>;`
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct Local {
ty: P<Ty>,
pat: @Pat,
@ -478,7 +478,7 @@ pub struct Local {
pub type Decl = Spanned<Decl_>;
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub enum Decl_ {
// a local (let) binding:
DeclLocal(@Local),
@ -514,7 +514,7 @@ pub enum UnsafeSource {
UserProvided,
}
#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Expr {
id: NodeId,
node: Expr_,
@ -732,7 +732,7 @@ pub struct MutTy {
mutbl: Mutability,
}
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct TypeField {
ident: Ident,
mt: MutTy,
@ -836,7 +836,7 @@ impl fmt::Show for Onceness {
}
}
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct ClosureTy {
sigil: Sigil,
region: Option<Lifetime>,
@ -967,7 +967,7 @@ pub enum ExplicitSelf_ {
pub type ExplicitSelf = Spanned<ExplicitSelf_>;
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct Method {
ident: Ident,
attrs: ~[Attribute],
@ -987,7 +987,7 @@ pub struct Mod {
items: ~[@Item],
}
#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct ForeignMod {
abis: AbiSet,
view_items: ~[ViewItem],
@ -1074,14 +1074,14 @@ pub type Attribute = Spanned<Attribute_>;
// 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,Hash)]
#[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,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Attribute_ {
style: AttrStyle,
value: @MetaItem,
@ -1095,13 +1095,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,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct TraitRef {
path: Path,
ref_id: NodeId,
}
#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Visibility {
Public,
Private,
@ -1117,7 +1117,7 @@ impl Visibility {
}
}
#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct StructField_ {
kind: StructFieldKind,
id: NodeId,
@ -1127,13 +1127,13 @@ pub struct StructField_ {
pub type StructField = Spanned<StructField_>;
#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum StructFieldKind {
NamedField(Ident, Visibility),
UnnamedField // element of a tuple-like struct
}
#[deriving(Eq, Encodable, Decodable,Hash)]
#[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
@ -1173,7 +1173,7 @@ pub enum Item_ {
ItemMac(Mac),
}
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct ForeignItem {
ident: Ident,
attrs: ~[Attribute],
@ -1183,7 +1183,7 @@ pub struct ForeignItem {
vis: Visibility,
}
#[deriving(Eq, Encodable, Decodable,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub enum ForeignItem_ {
ForeignItemFn(P<FnDecl>, Generics),
ForeignItemStatic(P<Ty>, /* is_mutbl */ bool),
@ -1192,7 +1192,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,Hash)]
#[deriving(Eq, Encodable, Decodable, Hash)]
pub enum InlinedItem {
IIItem(@Item),
IIMethod(DefId /* impl id */, bool /* is provided */, @Method),

2
src/libsyntax/codemap.rs
View File

@ -38,7 +38,7 @@ 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,Hash, Ord)]
#[deriving(Eq, Hash, Ord)]
pub struct CharPos(uint);
// FIXME: Lots of boilerplate in these impls, but so far my attempts to fix

6
src/libsyntax/util/interner.rs
View File

@ -75,8 +75,7 @@ impl<T:Eq + Hash + Freeze + Clone + 'static> Interner<T> {
vect.get().len()
}
pub fn find_equiv<Q:Hash + Equiv<T>>(&self, val: &Q)
-> Option<Name> {
pub fn find_equiv<Q:Hash + Equiv<T>>(&self, val: &Q) -> Option<Name> {
let map = self.map.borrow();
match map.get().find_equiv(val) {
Some(v) => Some(*v),
@ -207,8 +206,7 @@ impl StrInterner {
vect.get().len()
}
pub fn find_equiv<Q:Hash + Equiv<RcStr>>(&self, val: &Q)
-> Option<Name> {
pub fn find_equiv<Q:Hash + Equiv<RcStr>>(&self, val: &Q) -> Option<Name> {
let map = self.map.borrow();
match map.get().find_equiv(val) {
Some(v) => Some(*v),

3
src/test/run-pass/deriving-global.rs
View File

@ -27,18 +27,21 @@ mod submod {
// function calls, then being in a submodule will (correctly)
// cause errors about unrecognised module `std` (or `extra`)
#[deriving(Eq, Ord, TotalEq, TotalOrd,
Hash,
Clone, DeepClone,
Show, Rand,
Encodable, Decodable)]
enum A { A1(uint), A2(int) }
#[deriving(Eq, Ord, TotalEq, TotalOrd,
Hash,
Clone, DeepClone,
Show, Rand,
Encodable, Decodable)]
struct B { x: uint, y: int }
#[deriving(Eq, Ord, TotalEq, TotalOrd,
Hash,
Clone, DeepClone,
Show, Rand,
Encodable, Decodable)]

6
src/test/run-pass/deriving-meta-multiple.rs
View File

@ -10,8 +10,9 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(Eq)]
#[deriving(Clone)]
use std::hash::hash;
#[deriving(Eq, Clone, Hash)]
struct Foo {
bar: uint,
baz: int
@ -22,4 +23,5 @@ 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
hash(&a); // check for Hash impl w/o testing its correctness
}

5
src/test/run-pass/deriving-meta.rs
View File

@ -10,7 +10,9 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(Eq, Clone)]
use std::hash::hash;
#[deriving(Eq, Clone, Hash)]
struct Foo {
bar: uint,
baz: int
@ -21,4 +23,5 @@ 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
hash(&a); // check for Hash impl w/o testing its correctness
}

3
src/test/run-pass/deriving-via-extension-type-params.rs
View File

@ -10,8 +10,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(Eq)]
#[deriving(Hash)]
#[deriving(Eq, Hash)]
struct Foo<T> {
x: int,
y: T,