fix the `&mut _` patterns

src/libcollections/vec.rs

@@ -2030,7 +2030,7 @@ fn zero_sized_values() {
         v.push(());
         assert_eq!(v.iter_mut().count(), 4);
 
-        for &() in v.iter_mut() {}
+        for &mut () in v.iter_mut() {}
         unsafe { v.set_len(0); }
         assert_eq!(v.iter_mut().count(), 0);
     }

src/libcore/iter.rs

@@ -2344,7 +2344,7 @@ fn idx(&mut self, index: uint) -> Option<A> {
 ///
 /// // This iterator will yield up to the last Fibonacci number before the max value of `u32`.
 /// // You can simply change `u32` to `u64` in this line if you want higher values than that.
-/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&(ref mut x2, ref mut x1)| {
+/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&mut (ref mut x2, ref mut x1)| {
 ///     // Attempt to get the next Fibonacci number
 ///     // `x1` will be `None` if previously overflowed.
 ///     let next = match (*x2, *x1) {

src/libcore/option.rs

@@ -533,7 +533,7 @@ pub fn iter(&self) -> Iter<T> {
     /// ```
     /// let mut x = Some(4u);
     /// match x.iter_mut().next() {
-    ///     Some(&ref mut v) => *v = 42u,
+    ///     Some(&mut ref mut v) => *v = 42u,
     ///     None => {},
     /// }
     /// assert_eq!(x, Some(42));

src/libcore/result.rs

@@ -383,8 +383,8 @@ pub fn as_ref(&self) -> Result<&T, &E> {
     /// ```
     /// fn mutate(r: &mut Result<int, int>) {
     ///     match r.as_mut() {
-    ///         Ok(&ref mut v) => *v = 42,
-    ///         Err(&ref mut e) => *e = 0,
+    ///         Ok(&mut ref mut v) => *v = 42,
+    ///         Err(&mut ref mut e) => *e = 0,
     ///     }
     /// }
     ///
@@ -529,7 +529,7 @@ pub fn iter(&self) -> Iter<T> {
     /// ```
     /// let mut x: Result<uint, &str> = Ok(7);
     /// match x.iter_mut().next() {
-    ///     Some(&ref mut x) => *x = 40,
+    ///     Some(&mut ref mut x) => *x = 40,
     ///     None => {},
     /// }
     /// assert_eq!(x, Ok(40));

src/libcoretest/any.rs

@@ -101,12 +101,12 @@ fn any_downcast_mut() {
     }
 
     match a_r.downcast_mut::<uint>() {
-        Some(&612) => {}
+        Some(&mut 612) => {}
         x => panic!("Unexpected value {:?}", x)
     }
 
     match b_r.downcast_mut::<uint>() {
-        Some(&413) => {}
+        Some(&mut 413) => {}
         x => panic!("Unexpected value {:?}", x)
     }
 }

src/librustc_driver/pretty.rs

@@ -350,8 +350,8 @@ impl<'a, 'ast> Iterator for NodesMatchingUII<'a, 'ast> {
 
     fn next(&mut self) -> Option<ast::NodeId> {
         match self {
-            &NodesMatchingDirect(ref mut iter) => iter.next(),
-            &NodesMatchingSuffix(ref mut iter) => iter.next(),
+            &mut NodesMatchingDirect(ref mut iter) => iter.next(),
+            &mut NodesMatchingSuffix(ref mut iter) => iter.next(),
         }
     }
 }

src/librustc_typeck/check/mod.rs

@@ -1709,7 +1709,7 @@ pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
     /// ! gets replaced with (), unconstrained ints with i32, and unconstrained floats with f64.
     pub fn default_type_parameters(&self) {
         use middle::ty::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat, Neither};
-        for (_, &ref ty) in self.inh.node_types.borrow_mut().iter_mut() {
+        for (_, &mut ref ty) in self.inh.node_types.borrow_mut().iter_mut() {
             let resolved = self.infcx().resolve_type_vars_if_possible(ty);
             if self.infcx().type_var_diverges(resolved) {
                 demand::eqtype(self, codemap::DUMMY_SP, *ty, ty::mk_nil(self.tcx()));

src/libstd/sync/mpsc/stream.rs

@@ -338,7 +338,7 @@ pub fn can_recv(&mut self) -> Result<bool, Receiver<T>> {
         // upgrade pending, then go through the whole recv rigamarole to update
         // the internal state.
         match self.queue.peek() {
-            Some(&GoUp(..)) => {
+            Some(&mut GoUp(..)) => {
                 match self.recv() {
                     Err(Upgraded(port)) => Err(port),
                     _ => unreachable!(),
@@ -367,7 +367,7 @@ pub fn start_selection(&mut self, token: SignalToken) -> SelectionResult<T> {
             Ok(()) => SelSuccess,
             Err(token) => {
                 let ret = match self.queue.peek() {
-                    Some(&GoUp(..)) => {
+                    Some(&mut GoUp(..)) => {
                         match self.queue.pop() {
                             Some(GoUp(port)) => SelUpgraded(token, port),
                             _ => unreachable!(),
@@ -457,7 +457,7 @@ pub fn abort_selection(&mut self,
         // upgraded port.
         if has_data {
             match self.queue.peek() {
-                Some(&GoUp(..)) => {
+                Some(&mut GoUp(..)) => {
                     match self.queue.pop() {
                         Some(GoUp(port)) => Err(port),
                         _ => unreachable!(),

src/libsyntax/ast_map/mod.rs

@@ -90,7 +90,7 @@ impl<'a, T: Copy> Iterator for Values<'a, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
-        let &Values(ref mut items) = self;
+        let &mut Values(ref mut items) = self;
         items.next().map(|&x| x)
     }
 }

src/test/bench/shootout-meteor.rs

@@ -118,7 +118,7 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> {
     // translating to (0, 0) as minimum coordinates.
     for cur_piece in res.iter_mut() {
         let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap();
-        for &(ref mut y, ref mut x) in cur_piece.iter_mut() {
+        for &mut (ref mut y, ref mut x) in cur_piece.iter_mut() {
             *y -= dy; *x -= dx;
         }
     }

src/test/compile-fail/issue-15756.rs

@@ -14,7 +14,7 @@
 fn dft_iter<'a, T>(arg1: Chunks<'a,T>, arg2: ChunksMut<'a,T>)
 {
     for
-    &something
+    &mut something
 //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[T]`
     in arg2
     {

src/test/compile-fail/mut-pattern-mismatched.rs

@@ -13,7 +13,7 @@ fn main() {
 
     // (separate lines to ensure the spans are accurate)
 
-     let &_ // ~ ERROR expected `&mut isize`, found `&_`
+     let &_ //~ ERROR expected `&mut isize`, found `&_`
         = foo;
     let &mut _ = foo;
 

src/test/compile-fail/pattern-bindings-after-at.rs

@@ -15,7 +15,7 @@ enum Option<T> {
 
 fn main() {
     match &mut Some(1i) {
-        ref mut z @ &Some(ref a) => {
+        ref mut z @ &mut Some(ref a) => {
         //~^ ERROR pattern bindings are not allowed after an `@`
             **z = None;
             println!("{}", *a);

src/test/run-pass/drop-trait-enum.rs

@@ -36,13 +36,13 @@ enum Foo {
 impl Drop for Foo {
     fn drop(&mut self) {
         match self {
-            &Foo::SimpleVariant(ref mut sender) => {
+            &mut Foo::SimpleVariant(ref mut sender) => {
                 sender.send(Message::DestructorRan).unwrap();
             }
-            &Foo::NestedVariant(_, _, ref mut sender) => {
+            &mut Foo::NestedVariant(_, _, ref mut sender) => {
                 sender.send(Message::DestructorRan).unwrap();
             }
-            &Foo::FailingVariant { .. } => {
+            &mut Foo::FailingVariant { .. } => {
                 panic!("Failed");
             }
         }

src/test/run-pass/issue-16774.rs

@@ -36,7 +36,7 @@ fn deref(&self) -> &int {
 
 impl DerefMut for X {
     fn deref_mut(&mut self) -> &mut int {
-        let &X(box ref mut x) = self;
+        let &mut X(box ref mut x) = self;
         x
     }
 }