---

yaml
---
r: 152513
b: refs/heads/try2
c: d2d8fa2
h: refs/heads/master
i:
  152511: 0724393
v: v3

Author: Cameron Zwarich

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2c6caad1bab0660ce8b4797c10d5530964d6e8d9
+refs/heads/try2: d2d8fa2a0980fc6bf1a842cfff7d77ae9b95185f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/num/int_macros.rs

@@ -113,33 +113,6 @@ mod tests {
         assert!((0b1111001 as $T).count_zeros() == BITS as $T - 5);
     }
 
-    #[test]
-    fn test_swap_bytes() {
-        let n: $T = 0b0101100; assert_eq!(n.swap_bytes().swap_bytes(), n);
-        let n: $T = 0b0100001; assert_eq!(n.swap_bytes().swap_bytes(), n);
-        let n: $T = 0b1111001; assert_eq!(n.swap_bytes().swap_bytes(), n);
-
-        // Swapping these should make no difference
-        let n: $T = 0;   assert_eq!(n.swap_bytes(), n);
-        let n: $T = -1;  assert_eq!(n.swap_bytes(), n);
-    }
-
-    #[test]
-    fn test_rotate() {
-        let n: $T = 0b0101100; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-        let n: $T = 0b0100001; assert_eq!(n.rotate_left(3).rotate_left(2).rotate_right(5),  n);
-        let n: $T = 0b1111001; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-
-        // Rotating these should make no difference
-        //
-        // We test using 124 bits because to ensure that overlong bit shifts do
-        // not cause undefined behaviour. See #10183.
-        let n: $T = 0;   assert_eq!(n.rotate_left(124), n);
-        let n: $T = -1;  assert_eq!(n.rotate_left(124), n);
-        let n: $T = 0;   assert_eq!(n.rotate_right(124), n);
-        let n: $T = -1;  assert_eq!(n.rotate_right(124), n);
-    }
-
     #[test]
     fn test_signed_checked_div() {
         assert!(10i.checked_div(&2) == Some(5));

branches/try2/src/libcore/num/mod.rs

@@ -436,135 +436,57 @@ pub trait Bitwise: Bounded
     /// assert_eq!(n.trailing_zeros(), 3);
     /// ```
     fn trailing_zeros(&self) -> Self;
-
-    /// Reverses the byte order of a binary number.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::num::Bitwise;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0xEFCDAB8967452301u64;
-    /// assert_eq!(n.swap_bytes(), m);
-    /// ```
-    fn swap_bytes(&self) -> Self;
-
-    /// Shifts the bits to the left by a specified amount amount, `r`, wrapping
-    /// the truncated bits to the end of the resulting value.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::num::Bitwise;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0x3456789ABCDEF012u64;
-    /// assert_eq!(n.rotate_left(12), m);
-    /// ```
-    fn rotate_left(&self, r: uint) -> Self;
-
-    /// Shifts the bits to the right by a specified amount amount, `r`, wrapping
-    /// the truncated bits to the beginning of the resulting value.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::num::Bitwise;
-    ///
-    /// let n = 0x0123456789ABCDEFu64;
-    /// let m = 0xDEF0123456789ABCu64;
-    /// assert_eq!(n.rotate_right(12), m);
-    /// ```
-    fn rotate_right(&self, r: uint) -> Self;
 }
 
-/// Swapping a single byte does nothing. This is unsafe to be consistent with
-/// the other `bswap` intrinsics.
-#[inline]
-unsafe fn bswap8(x: u8) -> u8 { x }
-
 macro_rules! bitwise_impl(
-    ($t:ty, $bits:expr, $co:ident, $lz:ident, $tz:ident, $bs:path) => {
+    ($t:ty, $co:path, $lz:path, $tz:path) => {
         impl Bitwise for $t {
             #[inline]
-            fn count_ones(&self) -> $t { unsafe { intrinsics::$co(*self) } }
+            fn count_ones(&self) -> $t { unsafe { $co(*self) } }
 
             #[inline]
-            fn leading_zeros(&self) -> $t { unsafe { intrinsics::$lz(*self) } }
+            fn leading_zeros(&self) -> $t { unsafe { $lz(*self) } }
 
             #[inline]
-            fn trailing_zeros(&self) -> $t { unsafe { intrinsics::$tz(*self) } }
-
-            #[inline]
-            fn swap_bytes(&self) -> $t { unsafe { $bs(*self) } }
-
-            #[inline]
-            fn rotate_left(&self, r: uint) -> $t {
-                // Protect against undefined behaviour for overlong bit shifts
-                let r = r % $bits;
-                (*self << r) | (*self >> ($bits - r))
-            }
-
-            #[inline]
-            fn rotate_right(&self, r: uint) -> $t {
-                // Protect against undefined behaviour for overlong bit shifts
-                let r = r % $bits;
-                (*self >> r) | (*self << ($bits - r))
-            }
+            fn trailing_zeros(&self) -> $t { unsafe { $tz(*self) } }
         }
     }
 )
 
 macro_rules! bitwise_cast_impl(
-    ($t:ty, $t_cast:ty, $bits:expr,  $co:ident, $lz:ident, $tz:ident, $bs:path) => {
+    ($t:ty, $t_cast:ty,  $co:path, $lz:path, $tz:path) => {
         impl Bitwise for $t {
             #[inline]
-            fn count_ones(&self) -> $t { unsafe { intrinsics::$co(*self as $t_cast) as $t } }
-
-            #[inline]
-            fn leading_zeros(&self) -> $t { unsafe { intrinsics::$lz(*self as $t_cast) as $t } }
-
-            #[inline]
-            fn trailing_zeros(&self) -> $t { unsafe { intrinsics::$tz(*self as $t_cast) as $t } }
+            fn count_ones(&self) -> $t { unsafe { $co(*self as $t_cast) as $t } }
 
             #[inline]
-            fn swap_bytes(&self) -> $t { unsafe { $bs(*self as $t_cast) as $t } }
+            fn leading_zeros(&self) -> $t { unsafe { $lz(*self as $t_cast) as $t } }
 
             #[inline]
-            fn rotate_left(&self, r: uint) -> $t {
-                // cast to prevent the sign bit from being corrupted
-                (*self as $t_cast).rotate_left(r) as $t
-            }
-
-            #[inline]
-            fn rotate_right(&self, r: uint) -> $t {
-                // cast to prevent the sign bit from being corrupted
-                (*self as $t_cast).rotate_right(r) as $t
-            }
+            fn trailing_zeros(&self) -> $t { unsafe { $tz(*self as $t_cast) as $t } }
         }
     }
 )
 
 #[cfg(target_word_size = "32")]
-bitwise_cast_impl!(uint, u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
+bitwise_cast_impl!(uint, u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
 #[cfg(target_word_size = "64")]
-bitwise_cast_impl!(uint, u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
+bitwise_cast_impl!(uint, u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
 
-bitwise_impl!(u8, 8, ctpop8, ctlz8, cttz8, bswap8)
-bitwise_impl!(u16, 16, ctpop16, ctlz16, cttz16, intrinsics::bswap16)
-bitwise_impl!(u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
-bitwise_impl!(u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
+bitwise_impl!(u8, intrinsics::ctpop8, intrinsics::ctlz8, intrinsics::cttz8)
+bitwise_impl!(u16, intrinsics::ctpop16, intrinsics::ctlz16, intrinsics::cttz16)
+bitwise_impl!(u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
+bitwise_impl!(u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
 
 #[cfg(target_word_size = "32")]
-bitwise_cast_impl!(int, u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
+bitwise_cast_impl!(int, u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
 #[cfg(target_word_size = "64")]
-bitwise_cast_impl!(int, u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
+bitwise_cast_impl!(int, u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
 
-bitwise_cast_impl!(i8, u8, 8, ctpop8, ctlz8, cttz8, bswap8)
-bitwise_cast_impl!(i16, u16, 16, ctpop16, ctlz16, cttz16, intrinsics::bswap16)
-bitwise_cast_impl!(i32, u32, 32, ctpop32, ctlz32, cttz32, intrinsics::bswap32)
-bitwise_cast_impl!(i64, u64, 64, ctpop64, ctlz64, cttz64, intrinsics::bswap64)
+bitwise_cast_impl!(i8, u8, intrinsics::ctpop8, intrinsics::ctlz8, intrinsics::cttz8)
+bitwise_cast_impl!(i16, u16, intrinsics::ctpop16, intrinsics::ctlz16, intrinsics::cttz16)
+bitwise_cast_impl!(i32, u32, intrinsics::ctpop32, intrinsics::ctlz32, intrinsics::cttz32)
+bitwise_cast_impl!(i64, u64, intrinsics::ctpop64, intrinsics::ctlz64, intrinsics::cttz64)
 
 /// Specifies the available operations common to all of Rust's core numeric primitives.
 /// These may not always make sense from a purely mathematical point of view, but

branches/try2/src/libcore/num/uint_macros.rs

@@ -64,33 +64,6 @@ mod tests {
         assert!((0b1111001 as $T).count_zeros() == BITS as $T - 5);
     }
 
-    #[test]
-    fn test_swap_bytes() {
-        let n: $T = 0b0101100; assert_eq!(n.swap_bytes().swap_bytes(), n);
-        let n: $T = 0b0100001; assert_eq!(n.swap_bytes().swap_bytes(), n);
-        let n: $T = 0b1111001; assert_eq!(n.swap_bytes().swap_bytes(), n);
-
-        // Swapping these should make no difference
-        let n: $T = 0;   assert_eq!(n.swap_bytes(), n);
-        let n: $T = MAX; assert_eq!(n.swap_bytes(), n);
-    }
-
-    #[test]
-    fn test_rotate() {
-        let n: $T = 0b0101100; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-        let n: $T = 0b0100001; assert_eq!(n.rotate_left(3).rotate_left(2).rotate_right(5),  n);
-        let n: $T = 0b1111001; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-
-        // Rotating these should make no difference
-        //
-        // We test using 124 bits because to ensure that overlong bit shifts do
-        // not cause undefined behaviour. See #10183.
-        let n: $T = 0;   assert_eq!(n.rotate_left(124), n);
-        let n: $T = MAX; assert_eq!(n.rotate_left(124), n);
-        let n: $T = 0;   assert_eq!(n.rotate_right(124), n);
-        let n: $T = MAX; assert_eq!(n.rotate_right(124), n);
-    }
-
     #[test]
     fn test_unsigned_checked_div() {
         assert!(10u.checked_div(&2) == Some(5));

branches/try2/src/librustc/middle/borrowck/check_loans.rs

@@ -874,23 +874,30 @@ impl<'a> CheckLoanCtxt<'a> {
         // We must check every element of a move path. See
         // `borrowck-move-subcomponent.rs` for a test case.
 
-        // check for a conflicting loan:
         let mut ret = MoveOk;
-        self.each_in_scope_restriction(expr_id, move_path, |loan, _| {
-            // Any restriction prevents moves.
-            ret = MoveWhileBorrowed(loan.loan_path.clone(), loan.span);
-            false
-        });
+        let mut loan_path = move_path;
+        loop {
+            // check for a conflicting loan:
+            self.each_in_scope_restriction(expr_id, loan_path, |loan, _| {
+                // Any restriction prevents moves.
+                ret = MoveWhileBorrowed(loan.loan_path.clone(), loan.span);
+                false
+            });
 
-        if ret != MoveOk {
-            return ret
-        }
+            if ret != MoveOk {
+                return ret
+            }
 
-        match *move_path {
-            LpVar(_) => MoveOk,
-            LpExtend(ref subpath, _, _) => {
-                self.analyze_move_out_from(expr_id, &**subpath)
+            match *loan_path {
+                LpVar(_) => {
+                    ret = MoveOk;
+                    break;
+                }
+                LpExtend(ref lp_base, _, _) => {
+                    loan_path = &**lp_base;
+                }
             }
         }
+        ret
     }
 }

branches/try2/src/librustdoc/html/render.rs

@@ -2001,7 +2001,7 @@ impl<'a> fmt::Show for Sidebar<'a> {
                 let class = if cur.name.get_ref() == item &&
                                short == curty { "current" } else { "" };
                 try!(write!(w, "<a class='{ty} {class}' href='{href}{path}'>\
-                                {name}</a>",
+                                {name}</a><br/>",
                        ty = short,
                        class = class,
                        href = if curty == "mod" {"../"} else {""},

branches/try2/src/librustdoc/html/static/main.css

@@ -154,29 +154,25 @@ nav.sub {
 
 .block {
     padding: 0 10px;
-    margin-bottom: 14px;
+    margin-bottom: 10px;
 }
 .block h2 {
     margin-top: 0;
-    margin-bottom: 8px;
     text-align: center;
 }
 
 .block a {
-    display: block;
+    display: inline-block;
     text-overflow: ellipsis;
     overflow: hidden;
     line-height: 15px;
-    padding: 7px 5px;
+    padding-left: 5px;
+    padding-bottom: 6px;
     font-size: 14px;
     font-weight: 300;
     transition: border 500ms ease-out;
 }
 
-.block a:hover {
-    background: #F5F5F5;
-}
-
 .content {
     padding: 15px 0;
 }

branches/try2/src/librustdoc/html/static/main.js

@@ -647,6 +647,7 @@
                 }
                 div.append($('<a>', {'href': '../' + crates[i] + '/index.html',
                                     'class': klass}).text(crates[i]));
+                div.append($('<br>'));
             }
             sidebar.append(div);
         }