---

yaml
---
r: 97597
b: refs/heads/snap-stage3
c: 326e631
h: refs/heads/master
i:
  97595: c19271c
v: v3

Author: c-a

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 33e866339126df3806f9cae95f2b91d38abaab32
+refs/heads/snap-stage3: 326e63187ff4490c30ed603158e00c0be58dd162
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/guide-container.md

@@ -130,7 +130,7 @@ A typical mutable container will implement at least `iter()`, `mut_iter()` and
 ### Freezing
 
 Unlike most other languages with external iterators, Rust has no *iterator
-invalidation*. As long as an iterator is still in scope, the compiler will prevent
+invalidation*. As long an iterator is still in scope, the compiler will prevent
 modification of the container through another handle.
 
 ~~~

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -213,13 +213,11 @@ impl PurityState {
     }
 }
 
-/// Whether `check_binop` is part of an assignment or not.
-/// Used to know wether we allow user overloads and to print
-/// better messages on error.
+/// Whether `check_binop` allows overloaded operators to be invoked.
 #[deriving(Eq)]
-enum IsBinopAssignment{
-    SimpleBinop,
-    BinopAssignment,
+enum AllowOverloadedOperatorsFlag {
+    AllowOverloadedOperators,
+    DontAllowOverloadedOperators,
 }
 
 #[deriving(Clone)]
@@ -2088,7 +2086,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                    rhs: @ast::Expr,
                    // Used only in the error case
                    expected_result: Option<ty::t>,
-                   is_binop_assignment: IsBinopAssignment
+                   allow_overloaded_operators: AllowOverloadedOperatorsFlag
                   ) {
         let tcx = fcx.ccx.tcx;
 
@@ -2138,9 +2136,9 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
 
         }
 
-        // Check for overloaded operators if not an assignment.
+        // Check for overloaded operators if allowed.
         let result_t;
-        if is_binop_assignment == SimpleBinop {
+        if allow_overloaded_operators == AllowOverloadedOperators {
             result_t = check_user_binop(fcx,
                                         callee_id,
                                         expr,
@@ -2152,14 +2150,13 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
         } else {
             fcx.type_error_message(expr.span,
                                    |actual| {
-                                        format!("binary assignment operation \
-                                                {}= cannot be applied to type `{}`",
-                                                ast_util::binop_to_str(op),
-                                                actual)
+                                        format!("binary operation {} cannot be \
+                                              applied to type `{}`",
+                                             ast_util::binop_to_str(op),
+                                             actual)
                                    },
                                    lhs_t,
                                    None);
-            check_expr(fcx, rhs);
             result_t = ty::mk_err();
         }
 
@@ -2763,7 +2760,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                     lhs,
                     rhs,
                     expected,
-                    SimpleBinop);
+                    AllowOverloadedOperators);
 
         let lhs_ty = fcx.expr_ty(lhs);
         let rhs_ty = fcx.expr_ty(rhs);
@@ -2784,7 +2781,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                     lhs,
                     rhs,
                     expected,
-                    BinopAssignment);
+                    DontAllowOverloadedOperators);
 
         let lhs_t = fcx.expr_ty(lhs);
         let result_t = fcx.expr_ty(expr);

branches/snap-stage3/src/librustdoc/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -109,13 +109,7 @@ pub fn usage(argv0: &str) {
 }
 
 pub fn main_args(args: &[~str]) -> int {
-    let matches = match groups::getopts(args.tail(), opts()) {
-        Ok(m) => m,
-        Err(err) => {
-            println(err.to_err_msg());
-            return 1;
-        }
-    };
+    let matches = groups::getopts(args.tail(), opts()).unwrap();
     if matches.opt_present("h") || matches.opt_present("help") {
         usage(args[0]);
         return 0;

branches/snap-stage3/src/libstd/io/extensions.rs

@@ -465,4 +465,86 @@ mod test {
         assert!(reader.read_le_f32() == 8.1250);
     }
 
+    #[test]
+    fn test_u64_from_be_bytes() {
+        use super::u64_from_be_bytes;
+
+        let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09];
+
+        // Aligned access
+        assert_eq!(u64_from_be_bytes(buf, 0, 0), 0);
+        assert_eq!(u64_from_be_bytes(buf, 0, 1), 0x01);
+        assert_eq!(u64_from_be_bytes(buf, 0, 2), 0x0102);
+        assert_eq!(u64_from_be_bytes(buf, 0, 3), 0x010203);
+        assert_eq!(u64_from_be_bytes(buf, 0, 4), 0x01020304);
+        assert_eq!(u64_from_be_bytes(buf, 0, 5), 0x0102030405);
+        assert_eq!(u64_from_be_bytes(buf, 0, 6), 0x010203040506);
+        assert_eq!(u64_from_be_bytes(buf, 0, 7), 0x01020304050607);
+        assert_eq!(u64_from_be_bytes(buf, 0, 8), 0x0102030405060708);
+
+        // Unaligned access
+        assert_eq!(u64_from_be_bytes(buf, 1, 0), 0);
+        assert_eq!(u64_from_be_bytes(buf, 1, 1), 0x02);
+        assert_eq!(u64_from_be_bytes(buf, 1, 2), 0x0203);
+        assert_eq!(u64_from_be_bytes(buf, 1, 3), 0x020304);
+        assert_eq!(u64_from_be_bytes(buf, 1, 4), 0x02030405);
+        assert_eq!(u64_from_be_bytes(buf, 1, 5), 0x0203040506);
+        assert_eq!(u64_from_be_bytes(buf, 1, 6), 0x020304050607);
+        assert_eq!(u64_from_be_bytes(buf, 1, 7), 0x02030405060708);
+        assert_eq!(u64_from_be_bytes(buf, 1, 8), 0x0203040506070809);
+    }
+}
+
+#[cfg(test)]
+mod bench {
+    use extra::test::BenchHarness;
+    use container::Container;
+
+    macro_rules! u64_from_be_bytes_bench_impl(
+        ($size:expr, $stride:expr, $start_index:expr) =>
+        ({
+            use vec;
+            use super::u64_from_be_bytes;
+
+            let data = vec::from_fn($stride*100+$start_index, |i| i as u8);
+            let mut sum = 0u64;
+            bh.iter(|| {
+                let mut i = $start_index;
+                while (i < data.len()) {
+                    sum += u64_from_be_bytes(data, i, $size);
+                    i += $stride;
+                }
+            });
+        })
+    )
+
+    #[bench]
+    fn u64_from_be_bytes_4_aligned(bh: &mut BenchHarness) {
+        u64_from_be_bytes_bench_impl!(4, 4, 0);
+    }
+
+    #[bench]
+    fn u64_from_be_bytes_4_unaligned(bh: &mut BenchHarness) {
+        u64_from_be_bytes_bench_impl!(4, 4, 1);
+    }
+
+    #[bench]
+    fn u64_from_be_bytes_7_aligned(bh: &mut BenchHarness) {
+        u64_from_be_bytes_bench_impl!(7, 8, 0);
+    }
+
+    #[bench]
+    fn u64_from_be_bytes_7_unaligned(bh: &mut BenchHarness) {
+        u64_from_be_bytes_bench_impl!(7, 8, 1);
+    }
+
+    #[bench]
+    fn u64_from_be_bytes_8_aligned(bh: &mut BenchHarness) {
+        u64_from_be_bytes_bench_impl!(8, 8, 0);
+    }
+
+    #[bench]
+    fn u64_from_be_bytes_8_unaligned(bh: &mut BenchHarness) {
+        u64_from_be_bytes_bench_impl!(8, 8, 1);
+    }
 }

branches/snap-stage3/src/test/compile-fail/assignment-operator-unimplemented.rs

@@ -11,5 +11,5 @@
 // Regression test for issue #5239
 
 fn main() {
-    let x: |int| -> int = |ref x| { x += 1; }; //~ ERROR binary assignment operation += cannot be applied to type `&int`
+    let x: |int| -> int = |ref x| { x += 1; }; //~ ERROR binary operation + cannot be applied to type `&int`
 }