---

yaml
---
r: 273683
b: refs/heads/beta
c: 01c0723
h: refs/heads/master
i:
  273681: d7beeb2
  273679: 760ea36

Author: durka

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: abb3a107e45b93ca5332ab11bfa6cc8d5a882fb4
+refs/heads/beta: 01c0723ef247fec4b85af203c7247b66e3817e1b
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/librustc/ty/mod.rs

@@ -1202,7 +1202,6 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
         }
     }
 
-    /// Construct a parameter environment given an item, impl item, or trait item
     pub fn for_item(cx: &'a TyCtxt<'tcx>, id: NodeId) -> ParameterEnvironment<'a, 'tcx> {
         match cx.map.find(id) {
             Some(ast_map::NodeImplItem(ref impl_item)) => {
@@ -1342,7 +1341,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                     }
                     _ => {
                         cx.sess.span_bug(item.span,
-                                         "ParameterEnvironment::for_item():
+                                         "ParameterEnvironment::from_item():
                                           can't create a parameter \
                                           environment for this kind of item")
                     }
@@ -1353,7 +1352,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                 ParameterEnvironment::for_item(cx, cx.map.get_parent(id))
             }
             _ => {
-                cx.sess.bug(&format!("ParameterEnvironment::for_item(): \
+                cx.sess.bug(&format!("ParameterEnvironment::from_item(): \
                                      `{}` is not an item",
                                     cx.map.node_to_string(id)))
             }

branches/beta/src/libstd/sys/windows/net.rs

@@ -61,28 +61,27 @@ fn last_error() -> io::Error {
 }
 
 /// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1)
-/// and if so, returns the last error from the Windows socket interface. This
+/// and if so, returns the last error from the Windows socket interface. . This
 /// function must be called before another call to the socket API is made.
-pub fn cvt<T: One + PartialEq + Neg<Output=T>>(t: T) -> io::Result<T> {
-    if t == -T::one() {
+pub fn cvt<T: One + Neg<Output=T> + PartialEq>(t: T) -> io::Result<T> {
+    let one: T = T::one();
+    if t == -one {
         Err(last_error())
     } else {
         Ok(t)
     }
 }
 
-/// A variant of `cvt` for `getaddrinfo` which return 0 for a success.
+/// Provides the functionality of `cvt` for the return values of `getaddrinfo`
+/// and similar, meaning that they return an error if the return value is 0.
 pub fn cvt_gai(err: c_int) -> io::Result<()> {
-    if err == 0 {
-        Ok(())
-    } else {
-        Err(last_error())
-    }
+    if err == 0 { return Ok(()) }
+    cvt(err).map(|_| ())
 }
 
-/// Just to provide the same interface as sys/unix/net.rs
+/// Provides the functionality of `cvt` for a closure.
 pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
-    where T: One + PartialEq + Neg<Output=T>, F: FnMut() -> T
+    where F: FnMut() -> T, T: One + Neg<Output=T> + PartialEq
 {
     cvt(f())
 }

branches/beta/src/test/run-pass/deriving-hash.rs

@@ -12,6 +12,7 @@
 #![feature(hash_default)]
 
 use std::hash::{Hash, SipHasher, Hasher};
+use std::mem::size_of;
 
 #[derive(Hash)]
 struct Person {
@@ -24,12 +25,30 @@ struct Person {
 #[derive(Hash)] struct __H__H;
 #[derive(Hash)] enum Collision<__H> { __H { __H__H: __H } }
 
+#[derive(Hash)]
+enum E { A=1, B }
+
 fn hash<T: Hash>(t: &T) -> u64 {
     let mut s = SipHasher::new_with_keys(0, 0);
     t.hash(&mut s);
     s.finish()
 }
 
+struct FakeHasher<'a>(&'a mut Vec<u8>);
+impl<'a> Hasher for FakeHasher<'a> {
+    fn finish(&self) -> u64 {
+        unimplemented!()
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.extend(bytes);
+    }
+}
+
+fn fake_hash(v: &mut Vec<u8>, e: E) {
+    e.hash(&mut FakeHasher(v));
+}
+
 fn main() {
     let person1 = Person {
         id: 5,
@@ -43,4 +62,11 @@ fn main() {
     };
     assert_eq!(hash(&person1), hash(&person1));
     assert!(hash(&person1) != hash(&person2));
+
+    // test #21714
+    let mut va = vec![];
+    let mut vb = vec![];
+    fake_hash(&mut va, E::A);
+    fake_hash(&mut vb, E::B);
+    assert!(va != vb);
 }