Merge pull request capnproto#345 from danieleades/use-of-ref

remove unnecessary use of 'ref'

benchmark/benchmark.rs

@@ -174,10 +174,7 @@ impl<'a> Scratch<'a> for UseScratch {
     type Allocator = message::ScratchSpaceHeapAllocator<'a>;
 
     fn get_allocators(&'a mut self) -> (Self::Allocator, Self::Allocator) {
-        let UseScratch {
-            ref mut buffer1,
-            ref mut buffer2,
-        } = self;
+        let UseScratch { buffer1, buffer2 } = self;
         (
             message::ScratchSpaceHeapAllocator::new(capnp::Word::words_to_bytes_mut(buffer1)),
             message::ScratchSpaceHeapAllocator::new(capnp::Word::words_to_bytes_mut(buffer2)),

capnp-rpc/src/queued.rs

@@ -143,7 +143,7 @@ impl PipelineHook for Pipeline {
     }
 
     fn get_pipelined_cap_move(&self, ops: Vec<PipelineOp>) -> Box<dyn ClientHook> {
-        if let Some(ref p) = self.inner.borrow().redirect {
+        if let Some(p) = &self.inner.borrow().redirect {
             return p.get_pipelined_cap_move(ops);
         }
 
@@ -258,7 +258,7 @@ impl ClientHook for Client {
         params: Box<dyn ParamsHook>,
         results: Box<dyn ResultsHook>,
     ) -> Promise<(), Error> {
-        if let Some(ref client) = self.inner.borrow().redirect {
+        if let Some(client) = &self.inner.borrow().redirect {
             return client.call(interface_id, method_id, params, results);
         }
 
@@ -288,20 +288,20 @@ impl ClientHook for Client {
     }
 
     fn get_resolved(&self) -> Option<Box<dyn ClientHook>> {
-        match self.inner.borrow().redirect {
-            Some(ref inner) => Some(inner.clone()),
+        match &self.inner.borrow().redirect {
+            Some(inner) => Some(inner.clone()),
             None => None,
         }
     }
 
     fn when_more_resolved(&self) -> Option<Promise<Box<dyn ClientHook>, Error>> {
-        if let Some(ref client) = self.inner.borrow().redirect {
+        if let Some(client) = &self.inner.borrow().redirect {
             return Some(Promise::ok(client.add_ref()));
         }
 
         let promise = self.inner.borrow_mut().client_resolution_queue.push(());
-        match self.inner.borrow().promise_to_drive {
-            Some(ref p) => Some(Promise::from_future(
+        match &self.inner.borrow().promise_to_drive {
+            Some(p) => Some(Promise::from_future(
                 futures::future::try_join(p.clone(), promise).map_ok(|v| v.1),
             )),
             None => Some(Promise::from_future(promise)),

capnp/src/lib.rs

@@ -287,18 +287,18 @@ pub enum OutputSegments<'a> {
 impl<'a> core::ops::Deref for OutputSegments<'a> {
     type Target = [&'a [u8]];
     fn deref(&self) -> &[&'a [u8]] {
-        match *self {
-            OutputSegments::SingleSegment(ref s) => s,
-            OutputSegments::MultiSegment(ref v) => v,
+        match self {
+            OutputSegments::SingleSegment(s) => s,
+            OutputSegments::MultiSegment(v) => v,
         }
     }
 }
 
 impl<'s> message::ReaderSegments for OutputSegments<'s> {
     fn get_segment(&self, id: u32) -> Option<&[u8]> {
-        match *self {
-            OutputSegments::SingleSegment(ref s) => s.get(id as usize).copied(),
-            OutputSegments::MultiSegment(ref v) => v.get(id as usize).copied(),
+        match self {
+            OutputSegments::SingleSegment(s) => s.get(id as usize).copied(),
+            OutputSegments::MultiSegment(v) => v.get(id as usize).copied(),
         }
     }
 }

capnp/src/message.rs

@@ -419,7 +419,7 @@ where
         }
         let (seg_start, _seg_len) = self.arena.get_segment_mut(0);
         let location: *mut u8 = seg_start;
-        let Self { ref mut arena } = *self;
+        let Self { arena } = self;
 
         any_pointer::Builder::new(layout::PointerBuilder::get_root(arena, 0, location))
     }

capnp/src/private/arena.rs

@@ -289,8 +289,8 @@ where
 {
     /// Allocates a new segment with capacity for at least `minimum_size` words.
     fn allocate_segment(&mut self, minimum_size: WordCount32) -> Result<()> {
-        let seg = match self.allocator {
-            Some(ref mut a) => a.allocate_segment(minimum_size),
+        let seg = match &mut self.allocator {
+            Some(a) => a.allocate_segment(minimum_size),
             None => unreachable!(),
         };
         self.segments.push(BuilderSegment {
@@ -332,7 +332,7 @@ where
     }
 
     fn deallocate_all(&mut self) {
-        if let Some(ref mut a) = self.allocator {
+        if let Some(a) = &mut self.allocator {
             for seg in &self.segments {
                 a.deallocate_segment(seg.ptr, seg.capacity, seg.allocated);
             }

capnp/src/private/layout.rs

@@ -2750,10 +2750,7 @@ impl CapTableReader {
                 if index >= hooks.len() {
                     None
                 } else {
-                    match hooks[index] {
-                        None => None,
-                        Some(ref hook) => Some(hook.add_ref()),
-                    }
+                    hooks[index].as_ref().map(|hook| hook.add_ref())
                 }
             }
         }
@@ -2785,10 +2782,7 @@ impl CapTableBuilder {
                 if index >= hooks.len() {
                     None
                 } else {
-                    match hooks[index] {
-                        None => None,
-                        Some(ref hook) => Some(hook.add_ref()),
-                    }
+                    hooks[index].as_ref().map(|hook| hook.add_ref())
                 }
             }
         }

capnpc/src/codegen.rs

@@ -128,7 +128,7 @@ impl CodeGenerationCommand {
             // It would be simpler to use the ? operator instead of a pattern match, but then the error message
             // would not include `filepath`.
             match ::std::fs::File::create(&filepath) {
-                Ok(ref mut writer) => {
+                Ok(mut writer) => {
                     writer.write_all(text.as_bytes()).map_err(convert_io_err)?;
                 }
                 Err(e) => {
@@ -325,9 +325,9 @@ pub enum FormattedText {
 }
 
 fn to_lines(ft: &FormattedText, indent: usize) -> Vec<String> {
-    match *ft {
-        Indent(ref ft) => to_lines(ft, indent + 1),
-        Branch(ref fts) => {
+    match ft {
+        Indent(ft) => to_lines(ft, indent + 1),
+        Branch(fts) => {
             let mut result = Vec::new();
             for ft in fts.iter() {
                 for line in &to_lines(ft, indent) {
@@ -336,7 +336,7 @@ fn to_lines(ft: &FormattedText, indent: usize) -> Vec<String> {
             }
             result
         }
-        Line(ref s) => {
+        Line(s) => {
             let mut s1: String = " ".repeat(indent * 2);
             s1.push_str(s);
             vec![s1.to_string()]
@@ -1057,7 +1057,7 @@ fn generate_setter(
             }
         }
     };
-    if let Some(ref reader_type) = maybe_reader_type {
+    if let Some(reader_type) = &maybe_reader_type {
         let return_type = if return_result {
             "-> ::capnp::Result<()>"
         } else {