fix the `&mut _` patterns

diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 04a2d5b5bc96c19e9222004a77390026c5df302f..2cff9b2cb92cb64eebb0786ee01a81dace05dcf2 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/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);
     }

diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index d30cfc405a1fface3eba57e663748b2f505869e4..87d61358ed36438ca140211972169bda3d8b243d 100644 (file)
--- a/src/libcore/iter.rs
+++ b/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) {

diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 272570a0d5bb93e0e48256625bd4ed76400c88c4..108cbadcc174da349d8dc7bf8d08f0932069b3d2 100644 (file)
--- a/src/libcore/option.rs
+++ b/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));

diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 95ae6ebfb68c30b9ad26a0cb1fd2b7fa5d75d588..7868ec67c8a3adfa915b3d90cd7a17c17f86f29b 100644 (file)
--- a/src/libcore/result.rs
+++ b/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));

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index c0be3a287940a9bbbac8546b48f764fcfc2f479f..e6a7170aceafb40ad57d559305f45f3c7b28fed4 100644 (file)
--- a/src/libcoretest/any.rs
+++ b/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)
     }
 }

diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index c090ba033a7207fae6210fbe4c93e0351bea9712..7592fbc05b3383afcf52457473095e2cec1d1f27 100644 (file)
--- a/src/librustc_driver/pretty.rs
+++ b/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(),
         }
     }
 }

diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index c2bad39b78b6f46d0764751ff048f03b407c3fad..2b7f615dc1288c4f35614096258dfd926a51dbc1 100644 (file)
--- a/src/librustc_typeck/check/mod.rs
+++ b/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()));

diff --git a/src/libstd/sync/mpsc/stream.rs b/src/libstd/sync/mpsc/stream.rs
index bd1e74a33902e15c306732bc8da3abf49f48208a..f4b20c7b74235613c9334d974a7636a183e89c16 100644 (file)
--- a/src/libstd/sync/mpsc/stream.rs
+++ b/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!(),

diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs
index adcb9ff9cc27a2f69c63f6ff5ff809961d242957..e6f2979a3f8eceb66aeb28fa45b0a6a74d743793 100644 (file)
--- a/src/libsyntax/ast_map/mod.rs
+++ b/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)
     }
 }

diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index 34a036eff375024fb839b8daaf2000b0f5c5fcb7..0480c9d884ad001d84dabb6ae80f642c4adebb16 100644 (file)
--- a/src/test/bench/shootout-meteor.rs
+++ b/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;
         }
     }

diff --git a/src/test/compile-fail/issue-15756.rs b/src/test/compile-fail/issue-15756.rs
index c2d30224dc87f8b8f2ce045754523a41d20c038a..02ccf9c0e08e7af6fd4daa7a6b6b49a4d61933bc 100644 (file)
--- a/src/test/compile-fail/issue-15756.rs
+++ b/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
     {

diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
index 714fbd082811959b11672610719e7c37208f123c..9f1d3d1fb391298559d99fc576f4b23b3304ea9a 100644 (file)
--- a/src/test/compile-fail/mut-pattern-mismatched.rs
+++ b/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;
 

diff --git a/src/test/compile-fail/pattern-bindings-after-at.rs b/src/test/compile-fail/pattern-bindings-after-at.rs
index 9cd2d0d28b165167ef1672a8e646cc28323b07b1..54ac3cba636f24abc6ddbf28dc75bda565d6f754 100644 (file)
--- a/src/test/compile-fail/pattern-bindings-after-at.rs
+++ b/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);

diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs
index f1cc4fb172409e20050ba03420e8732c87bce634..4c7b0680621784c290054a15cb16ff87928604a7 100644 (file)
--- a/src/test/run-pass/drop-trait-enum.rs
+++ b/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");
             }
         }

diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs
index 6ef4f868d215094faf76c687bd6be2ec5949d4d2..4246fced26c66e02ae9886405705458f2387f599 100644 (file)
--- a/src/test/run-pass/issue-16774.rs
+++ b/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
     }
 }