Remove unneeded ref patterns and destructures.

This brings the code to a more modern Rust style.

- Dstructuring is not so necessary nowadays, with the borrow checker being smarter, especially around partial captures in closures.
- "ref" is barely needed anymore, with [match ergonomics](https://rust-lang.github.io/rfcs/2005-match-ergonomics.html).

fuzz/fuzz_targets/dhcp_header.rs

@@ -4,7 +4,7 @@ use smoltcp::wire::{DhcpPacket, DhcpRepr};
 
 fuzz_target!(|data: &[u8]| {
     let _ = match DhcpPacket::new_checked(data) {
-        Ok(ref packet) => match DhcpRepr::parse(packet) {
+        Ok(packet) => match DhcpRepr::parse(packet) {
             Ok(dhcp_repr) => {
                 let mut dhcp_payload = vec![0; dhcp_repr.buffer_len()];
                 match DhcpPacket::new_checked(&mut dhcp_payload[..]) {

fuzz/fuzz_targets/ieee802154_header.rs

@@ -3,7 +3,7 @@ use libfuzzer_sys::fuzz_target;
 use smoltcp::wire::{Ieee802154Frame, Ieee802154Repr};
 
 fuzz_target!(|data: &[u8]| {
-    if let Ok(ref frame) = Ieee802154Frame::new_checked(data) {
+    if let Ok(frame) = Ieee802154Frame::new_checked(data) {
         if let Ok(repr) = Ieee802154Repr::parse(frame) {
             // The buffer len returns only the length required for emitting the header
             // and does not take into account the length of the payload.

src/iface/interface/ipv4.rs

@@ -348,28 +348,17 @@ impl InterfaceInner {
     pub(super) fn dispatch_ipv4_out_packet<Tx: TxToken>(
         &mut self,
         tx_token: Tx,
-        out_packet: &mut Ipv4OutPacket,
+        pkt: &mut Ipv4OutPacket,
     ) {
-        let Ipv4OutPacket {
-            buffer,
-            packet_len,
-            sent_bytes,
-            repr,
-            dst_hardware_addr,
-            frag_offset,
-            ident,
-            ..
-        } = out_packet;
-
         let caps = self.caps.clone();
 
         let mtu_max = self.ip_mtu();
-        let ip_len = (*packet_len - *sent_bytes + repr.buffer_len()).min(mtu_max);
-        let payload_len = ip_len - repr.buffer_len();
+        let ip_len = (pkt.packet_len - pkt.sent_bytes + pkt.repr.buffer_len()).min(mtu_max);
+        let payload_len = ip_len - pkt.repr.buffer_len();
 
-        let more_frags = (*packet_len - *sent_bytes) != payload_len;
-        repr.payload_len = payload_len;
-        *sent_bytes += payload_len;
+        let more_frags = (pkt.packet_len - pkt.sent_bytes) != payload_len;
+        pkt.repr.payload_len = payload_len;
+        pkt.sent_bytes += payload_len;
 
         let mut tx_len = ip_len;
         #[cfg(feature = "medium-ethernet")]
@@ -384,7 +373,7 @@ impl InterfaceInner {
 
             let src_addr = self.hardware_addr.unwrap().ethernet_or_panic();
             frame.set_src_addr(src_addr);
-            frame.set_dst_addr(*dst_hardware_addr);
+            frame.set_dst_addr(pkt.dst_hardware_addr);
 
             match repr.version() {
                 #[cfg(feature = "proto-ipv4")]
@@ -397,27 +386,27 @@ impl InterfaceInner {
         tx_token.consume(tx_len, |mut tx_buffer| {
             #[cfg(feature = "medium-ethernet")]
             if matches!(self.caps.medium, Medium::Ethernet) {
-                emit_ethernet(&IpRepr::Ipv4(*repr), tx_buffer);
+                emit_ethernet(&IpRepr::Ipv4(pkt.repr), tx_buffer);
                 tx_buffer = &mut tx_buffer[EthernetFrame::<&[u8]>::header_len()..];
             }
 
-            let mut packet = Ipv4Packet::new_unchecked(&mut tx_buffer[..repr.buffer_len()]);
-            repr.emit(&mut packet, &caps.checksum);
-            packet.set_ident(*ident);
+            let mut packet = Ipv4Packet::new_unchecked(&mut tx_buffer[..pkt.repr.buffer_len()]);
+            pkt.repr.emit(&mut packet, &caps.checksum);
+            packet.set_ident(pkt.ident);
             packet.set_more_frags(more_frags);
             packet.set_dont_frag(false);
-            packet.set_frag_offset(*frag_offset);
+            packet.set_frag_offset(pkt.frag_offset);
 
             if caps.checksum.ipv4.tx() {
                 packet.fill_checksum();
             }
 
-            tx_buffer[repr.buffer_len()..][..payload_len].copy_from_slice(
-                &buffer[*frag_offset as usize + repr.buffer_len()..][..payload_len],
+            tx_buffer[pkt.repr.buffer_len()..][..payload_len].copy_from_slice(
+                &pkt.buffer[pkt.frag_offset as usize + pkt.repr.buffer_len()..][..payload_len],
             );
 
             // Update the frag offset for the next fragment.
-            *frag_offset += payload_len as u16;
+            pkt.frag_offset += payload_len as u16;
         })
     }
 

src/iface/interface/mod.rs

@@ -997,10 +997,9 @@ impl Interface {
                     respond(inner, IpPacket::Dhcpv4(response))
                 }),
                 #[cfg(feature = "socket-dns")]
-                Socket::Dns(ref mut socket) => socket
-                    .dispatch(&mut self.inner, |inner, response| {
-                        respond(inner, IpPacket::Udp(response))
-                    }),
+                Socket::Dns(socket) => socket.dispatch(&mut self.inner, |inner, response| {
+                    respond(inner, IpPacket::Udp(response))
+                }),
             };
 
             match result {
@@ -1040,13 +1039,8 @@ impl Interface {
             return false;
         }
 
-        let Ipv4OutPacket {
-            packet_len,
-            sent_bytes,
-            ..
-        } = &self.out_packets.ipv4_out_packet;
-
-        if *packet_len > *sent_bytes {
+        let pkt = &self.out_packets.ipv4_out_packet;
+        if pkt.packet_len > pkt.sent_bytes {
             if let Some(tx_token) = device.transmit(self.inner.now) {
                 self.inner
                     .dispatch_ipv4_out_packet(tx_token, &mut self.out_packets.ipv4_out_packet);
@@ -1075,13 +1069,8 @@ impl Interface {
             return false;
         }
 
-        let SixlowpanOutPacket {
-            packet_len,
-            sent_bytes,
-            ..
-        } = &self.out_packets.sixlowpan_out_packet;
-
-        if *packet_len > *sent_bytes {
+        let pkt = &self.out_packets.sixlowpan_out_packet;
+        if pkt.packet_len > pkt.sent_bytes {
             if let Some(tx_token) = device.transmit(self.inner.now) {
                 self.inner.dispatch_ieee802154_out_packet(
                     tx_token,
@@ -1735,7 +1724,7 @@ impl InterfaceInner {
         packet: IpPacket,
         _out_packet: Option<&mut OutPackets>,
     ) -> Result<(), DispatchError> {
-        let mut ip_repr = packet.ip_repr();
+        let ip_repr = packet.ip_repr();
         assert!(!ip_repr.dst_addr().is_unspecified());
 
         // Dispatch IEEE802.15.4:
@@ -1814,23 +1803,14 @@ impl InterfaceInner {
 
         match ip_repr {
             #[cfg(feature = "proto-ipv4")]
-            IpRepr::Ipv4(ref mut repr) => {
+            IpRepr::Ipv4(mut repr) => {
                 // If we have an IPv4 packet, then we need to check if we need to fragment it.
                 if total_ip_len > self.caps.max_transmission_unit {
                     #[cfg(feature = "proto-ipv4-fragmentation")]
                     {
                         net_debug!("start fragmentation");
 
-                        let Ipv4OutPacket {
-                            buffer,
-                            packet_len,
-                            sent_bytes,
-                            repr: out_packet_repr,
-                            frag_offset,
-                            ident,
-                            #[cfg(feature = "medium-ethernet")]
-                                dst_hardware_addr: dst_address,
-                        } = &mut _out_packet.unwrap().ipv4_out_packet;
+                        let pkt = &mut _out_packet.unwrap().ipv4_out_packet;
 
                         // Calculate how much we will send now (including the Ethernet header).
                         let tx_len = self.caps.max_transmission_unit;
@@ -1838,7 +1818,7 @@ impl InterfaceInner {
                         let ip_header_len = repr.buffer_len();
                         let first_frag_ip_len = self.caps.ip_mtu();
 
-                        if buffer.len() < first_frag_ip_len {
+                        if pkt.buffer.len() < first_frag_ip_len {
                             net_debug!(
                                 "Fragmentation buffer is too small, at least {} needed. Dropping",
                                 first_frag_ip_len
@@ -1848,26 +1828,26 @@ impl InterfaceInner {
 
                         #[cfg(feature = "medium-ethernet")]
                         {
-                            *dst_address = dst_hardware_addr;
+                            pkt.dst_hardware_addr = dst_hardware_addr;
                         }
 
                         // Save the total packet len (without the Ethernet header, but with the first
                         // IP header).
-                        *packet_len = total_ip_len;
+                        pkt.packet_len = total_ip_len;
 
                         // Save the IP header for other fragments.
-                        *out_packet_repr = *repr;
+                        pkt.repr = repr;
 
                         // Save how much bytes we will send now.
-                        *sent_bytes = first_frag_ip_len;
+                        pkt.sent_bytes = first_frag_ip_len;
 
                         // Modify the IP header
                         repr.payload_len = first_frag_ip_len - repr.buffer_len();
 
                         // Emit the IP header to the buffer.
-                        emit_ip(&ip_repr, buffer);
-                        let mut ipv4_packet = Ipv4Packet::new_unchecked(&mut buffer[..]);
-                        *ident = ipv4_id;
+                        emit_ip(&ip_repr, &mut pkt.buffer);
+                        let mut ipv4_packet = Ipv4Packet::new_unchecked(&mut pkt.buffer[..]);
+                        pkt.ident = ipv4_id;
                         ipv4_packet.set_ident(ipv4_id);
                         ipv4_packet.set_more_frags(true);
                         ipv4_packet.set_dont_frag(false);
@@ -1886,11 +1866,11 @@ impl InterfaceInner {
                             }
 
                             // Change the offset for the next packet.
-                            *frag_offset = (first_frag_ip_len - ip_header_len) as u16;
+                            pkt.frag_offset = (first_frag_ip_len - ip_header_len) as u16;
 
                             // Copy the IP header and the payload.
                             tx_buffer[..first_frag_ip_len]
-                                .copy_from_slice(&buffer[..first_frag_ip_len]);
+                                .copy_from_slice(&pkt.buffer[..first_frag_ip_len]);
 
                             Ok(())
                         })

src/iface/interface/sixlowpan.rs

@@ -371,20 +371,9 @@ impl InterfaceInner {
 
                 // `dispatch_ieee802154_out_packet` requires some information about the total packet size,
                 // the link local source and destination address...
-                let SixlowpanOutPacket {
-                    buffer,
-                    packet_len,
-                    datagram_size,
-                    datagram_tag,
-                    sent_bytes,
-                    fragn_size,
-                    ll_dst_addr,
-                    ll_src_addr,
-                    datagram_offset,
-                    ..
-                } = &mut _out_packet.unwrap().sixlowpan_out_packet;
-
-                if buffer.len() < total_size {
+                let pkt = &mut _out_packet.unwrap().sixlowpan_out_packet;
+
+                if pkt.buffer.len() < total_size {
                     net_debug!(
                                 "dispatch_ieee802154: dropping, fragmentation buffer is too small, at least {} needed",
                                 total_size
@@ -392,14 +381,14 @@ impl InterfaceInner {
                     return;
                 }
 
-                *ll_dst_addr = ll_dst_a;
-                *ll_src_addr = ll_src_a;
+                pkt.ll_dst_addr = ll_dst_a;
+                pkt.ll_src_addr = ll_src_a;
 
                 let mut iphc_packet =
-                    SixlowpanIphcPacket::new_unchecked(&mut buffer[..iphc_repr.buffer_len()]);
+                    SixlowpanIphcPacket::new_unchecked(&mut pkt.buffer[..iphc_repr.buffer_len()]);
                 iphc_repr.emit(&mut iphc_packet);
 
-                let b = &mut buffer[iphc_repr.buffer_len()..];
+                let b = &mut pkt.buffer[iphc_repr.buffer_len()..];
 
                 match packet {
                     #[cfg(feature = "socket-udp")]
@@ -442,24 +431,24 @@ impl InterfaceInner {
                     _ => unreachable!(),
                 }
 
-                *packet_len = total_size;
+                pkt.packet_len = total_size;
 
                 // The datagram size that we need to set in the first fragment header is equal to the
                 // IPv6 payload length + 40.
-                *datagram_size = (packet.ip_repr().payload_len() + 40) as u16;
+                pkt.datagram_size = (packet.ip_repr().payload_len() + 40) as u16;
 
                 // We generate a random tag.
                 let tag = self.get_sixlowpan_fragment_tag();
                 // We save the tag for the other fragments that will be created when calling `poll`
                 // multiple times.
-                *datagram_tag = tag;
+                pkt.datagram_tag = tag;
 
                 let frag1 = SixlowpanFragRepr::FirstFragment {
-                    size: *datagram_size,
+                    size: pkt.datagram_size,
                     tag,
                 };
                 let fragn = SixlowpanFragRepr::Fragment {
-                    size: *datagram_size,
+                    size: pkt.datagram_size,
                     tag,
                     offset: 0,
                 };
@@ -475,10 +464,10 @@ impl InterfaceInner {
                 let frag1_size =
                     (125 - ieee_len - frag1.buffer_len() + header_diff) / 8 * 8 - (header_diff);
 
-                *fragn_size = (125 - ieee_len - fragn.buffer_len()) / 8 * 8;
+                pkt.fragn_size = (125 - ieee_len - fragn.buffer_len()) / 8 * 8;
 
-                *sent_bytes = frag1_size;
-                *datagram_offset = frag1_size + header_diff;
+                pkt.sent_bytes = frag1_size;
+                pkt.datagram_offset = frag1_size + header_diff;
 
                 tx_token.consume(ieee_len + frag1.buffer_len() + frag1_size, |mut tx_buf| {
                     // Add the IEEE header.
@@ -492,7 +481,7 @@ impl InterfaceInner {
                     tx_buf = &mut tx_buf[frag1.buffer_len()..];
 
                     // Add the buffer part.
-                    tx_buf[..frag1_size].copy_from_slice(&buffer[..frag1_size]);
+                    tx_buf[..frag1_size].copy_from_slice(&pkt.buffer[..frag1_size]);
                 });
             }
 
@@ -566,21 +555,8 @@ impl InterfaceInner {
     pub(super) fn dispatch_ieee802154_out_packet<Tx: TxToken>(
         &mut self,
         tx_token: Tx,
-        out_packet: &mut SixlowpanOutPacket,
+        pkt: &mut SixlowpanOutPacket,
     ) {
-        let SixlowpanOutPacket {
-            buffer,
-            packet_len,
-            datagram_size,
-            datagram_tag,
-            datagram_offset,
-            sent_bytes,
-            fragn_size,
-            ll_dst_addr,
-            ll_src_addr,
-            ..
-        } = out_packet;
-
         // Create the IEEE802.15.4 header.
         let ieee_repr = Ieee802154Repr {
             frame_type: Ieee802154FrameType::Data,
@@ -591,20 +567,20 @@ impl InterfaceInner {
             pan_id_compression: true,
             frame_version: Ieee802154FrameVersion::Ieee802154_2003,
             dst_pan_id: self.pan_id,
-            dst_addr: Some(*ll_dst_addr),
+            dst_addr: Some(pkt.ll_dst_addr),
             src_pan_id: self.pan_id,
-            src_addr: Some(*ll_src_addr),
+            src_addr: Some(pkt.ll_src_addr),
         };
 
         // Create the FRAG_N header.
         let fragn = SixlowpanFragRepr::Fragment {
-            size: *datagram_size,
-            tag: *datagram_tag,
-            offset: (*datagram_offset / 8) as u8,
+            size: pkt.datagram_size,
+            tag: pkt.datagram_tag,
+            offset: (pkt.datagram_offset / 8) as u8,
         };
 
         let ieee_len = ieee_repr.buffer_len();
-        let frag_size = (*packet_len - *sent_bytes).min(*fragn_size);
+        let frag_size = (pkt.packet_len - pkt.sent_bytes).min(pkt.fragn_size);
 
         tx_token.consume(
             ieee_repr.buffer_len() + fragn.buffer_len() + frag_size,
@@ -619,10 +595,10 @@ impl InterfaceInner {
                 tx_buf = &mut tx_buf[fragn.buffer_len()..];
 
                 // Add the buffer part
-                tx_buf[..frag_size].copy_from_slice(&buffer[*sent_bytes..][..frag_size]);
+                tx_buf[..frag_size].copy_from_slice(&pkt.buffer[pkt.sent_bytes..][..frag_size]);
 
-                *sent_bytes += frag_size;
-                *datagram_offset += frag_size;
+                pkt.sent_bytes += frag_size;
+                pkt.datagram_offset += frag_size;
             },
         );
     }

src/iface/socket_set.rs

@@ -77,10 +77,10 @@ impl<'a> SocketSet<'a> {
             }
         }
 
-        match self.sockets {
+        match &mut self.sockets {
             ManagedSlice::Borrowed(_) => panic!("adding a socket to a full SocketSet"),
             #[cfg(feature = "alloc")]
-            ManagedSlice::Owned(ref mut sockets) => {
+            ManagedSlice::Owned(sockets) => {
                 sockets.push(SocketStorage { inner: None });
                 let index = sockets.len() - 1;
                 put(index, &mut sockets[index], socket)

src/phy/fuzz_injector.rs

@@ -62,18 +62,13 @@ where
     }
 
     fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
-        let &mut Self {
-            ref mut inner,
-            ref fuzz_rx,
-            ref fuzz_tx,
-        } = self;
-        inner.receive(timestamp).map(|(rx_token, tx_token)| {
+        self.inner.receive(timestamp).map(|(rx_token, tx_token)| {
             let rx = RxToken {
-                fuzzer: fuzz_rx,
+                fuzzer: &mut self.fuzz_rx,
                 token: rx_token,
             };
             let tx = TxToken {
-                fuzzer: fuzz_tx,
+                fuzzer: &mut self.fuzz_tx,
                 token: tx_token,
             };
             (rx, tx)
@@ -81,13 +76,8 @@ where
     }
 
     fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>> {
-        let &mut Self {
-            ref mut inner,
-            fuzz_rx: _,
-            ref fuzz_tx,
-        } = self;
-        inner.transmit(timestamp).map(|token| TxToken {
-            fuzzer: fuzz_tx,
+        self.inner.transmit(timestamp).map(|token| TxToken {
+            fuzzer: &mut self.fuzz_tx,
             token: token,
         })
     }

src/phy/raw_socket.rs

@@ -81,7 +81,7 @@ impl Device for RawSocket {
                 };
                 Some((rx, tx))
             }
-            Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => None,
+            Err(err) if err.kind() == io::ErrorKind::WouldBlock => None,
             Err(err) => panic!("{}", err),
         }
     }

src/phy/tracer.rs

@@ -54,22 +54,17 @@ impl<D: Device> Device for Tracer<D> {
     }
 
     fn receive(&mut self, timestamp: Instant) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
-        let &mut Self {
-            ref mut inner,
-            writer,
-            ..
-        } = self;
-        let medium = inner.capabilities().medium;
-        inner.receive(timestamp).map(|(rx_token, tx_token)| {
+        let medium = self.inner.capabilities().medium;
+        self.inner.receive(timestamp).map(|(rx_token, tx_token)| {
             let rx = RxToken {
                 token: rx_token,
-                writer,
+                writer: self.writer,
                 medium,
                 timestamp,
             };
             let tx = TxToken {
                 token: tx_token,
-                writer,
+                writer: self.writer,
                 medium,
                 timestamp,
             };
@@ -78,15 +73,11 @@ impl<D: Device> Device for Tracer<D> {
     }
 
     fn transmit(&mut self, timestamp: Instant) -> Option<Self::TxToken<'_>> {
-        let &mut Self {
-            ref mut inner,
-            writer,
-        } = self;
-        let medium = inner.capabilities().medium;
-        inner.transmit(timestamp).map(|tx_token| TxToken {
+        let medium = self.inner.capabilities().medium;
+        self.inner.transmit(timestamp).map(|tx_token| TxToken {
             token: tx_token,
             medium,
-            writer,
+            writer: self.writer,
             timestamp,
         })
     }

src/phy/tuntap_interface.rs

@@ -63,7 +63,7 @@ impl Device for TunTapInterface {
                 };
                 Some((rx, tx))
             }
-            Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => None,
+            Err(err) if err.kind() == io::ErrorKind::WouldBlock => None,
             Err(err) => panic!("{}", err),
         }
     }

src/socket/dns.rs

@@ -182,10 +182,10 @@ impl<'a> Socket<'a> {
             }
         }
 
-        match self.queries {
+        match &mut self.queries {
             ManagedSlice::Borrowed(_) => None,
             #[cfg(feature = "alloc")]
-            ManagedSlice::Owned(ref mut queries) => {
+            ManagedSlice::Owned(queries) => {
                 queries.push(None);
                 let index = queries.len() - 1;
                 Some(QueryHandle(index))

src/socket/icmp.rs

@@ -446,7 +446,7 @@ impl<'a> Socket<'a> {
     pub(crate) fn process(&mut self, _cx: &mut Context, ip_repr: &IpRepr, icmp_repr: &IcmpRepr) {
         match *icmp_repr {
             #[cfg(feature = "proto-ipv4")]
-            IcmpRepr::Ipv4(ref icmp_repr) => {
+            IcmpRepr::Ipv4(icmp_repr) => {
                 net_trace!("icmp: receiving {} octets", icmp_repr.buffer_len());
 
                 match self
@@ -463,7 +463,7 @@ impl<'a> Socket<'a> {
                 }
             }
             #[cfg(feature = "proto-ipv6")]
-            IcmpRepr::Ipv6(ref icmp_repr) => {
+            IcmpRepr::Ipv6(icmp_repr) => {
                 net_trace!("icmp: receiving {} octets", icmp_repr.buffer_len());
 
                 match self

src/socket/tcp.rs

@@ -273,10 +273,7 @@ impl Timer {
     }
 
     fn set_keep_alive(&mut self) {
-        if let Timer::Idle {
-            ref mut keep_alive_at,
-        } = *self
-        {
+        if let Timer::Idle { keep_alive_at } = self {
             if keep_alive_at.is_none() {
                 *keep_alive_at = Some(Instant::from_millis(0))
             }
@@ -284,10 +281,7 @@ impl Timer {
     }
 
     fn rewind_keep_alive(&mut self, timestamp: Instant, interval: Option<Duration>) {
-        if let Timer::Idle {
-            ref mut keep_alive_at,
-        } = *self
-        {
+        if let Timer::Idle { keep_alive_at } = self {
             *keep_alive_at = interval.map(|interval| timestamp + interval)
         }
     }
@@ -1734,9 +1728,9 @@ impl<'a> Socket<'a> {
                 // Duplicate ACK if payload empty and ACK doesn't move send window ->
                 // Increment duplicate ACK count and set for retransmit if we just received
                 // the third duplicate ACK
-                Some(ref last_rx_ack)
+                Some(last_rx_ack)
                     if repr.payload.is_empty()
-                        && *last_rx_ack == ack_number
+                        && last_rx_ack == ack_number
                         && ack_number < self.remote_last_seq =>
                 {
                     // Increment duplicate ACK count

src/storage/packet_buffer.rs

@@ -184,17 +184,15 @@ impl<'a, H> PacketBuffer<'a, H> {
         self.dequeue_padding();
 
         self.metadata_ring.dequeue_one_with(|metadata| {
-            let PacketMetadata {
-                ref mut header,
-                size,
-            } = *metadata;
-
             self.payload_ring
                 .dequeue_many_with(|payload_buf| {
-                    debug_assert!(payload_buf.len() >= size);
+                    debug_assert!(payload_buf.len() >= metadata.size);
 
-                    match f(header.as_mut().unwrap(), &mut payload_buf[..size]) {
-                        Ok(val) => (size, Ok(val)),
+                    match f(
+                        metadata.header.as_mut().unwrap(),
+                        &mut payload_buf[..metadata.size],
+                    ) {
+                        Ok(val) => (metadata.size, Ok(val)),
                         Err(err) => (0, Err(err)),
                     }
                 })
@@ -207,14 +205,11 @@ impl<'a, H> PacketBuffer<'a, H> {
     pub fn dequeue(&mut self) -> Result<(H, &mut [u8]), Empty> {
         self.dequeue_padding();
 
-        let PacketMetadata {
-            ref mut header,
-            size,
-        } = *self.metadata_ring.dequeue_one()?;
+        let meta = self.metadata_ring.dequeue_one()?;
 
-        let payload_buf = self.payload_ring.dequeue_many(size);
-        debug_assert!(payload_buf.len() == size);
-        Ok((header.take().unwrap(), payload_buf))
+        let payload_buf = self.payload_ring.dequeue_many(meta.size);
+        debug_assert!(payload_buf.len() == meta.size);
+        Ok((meta.header.take().unwrap(), payload_buf))
     }
 
     /// Peek at a single packet from the buffer without removing it, and return a reference to

src/wire/ieee802154.rs

@@ -637,21 +637,21 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Frame<T> {
 
     /// Set the destination address.
     #[inline]
-    pub fn set_dst_addr(&mut self, mut value: Address) {
+    pub fn set_dst_addr(&mut self, value: Address) {
         match value {
             Address::Absent => self.set_dst_addressing_mode(AddressingMode::Absent),
-            Address::Short(ref mut value) => {
+            Address::Short(mut value) => {
                 value.reverse();
                 self.set_dst_addressing_mode(AddressingMode::Short);
                 let data = self.buffer.as_mut();
-                data[field::ADDRESSING][2..2 + 2].copy_from_slice(value);
+                data[field::ADDRESSING][2..2 + 2].copy_from_slice(&value);
                 value.reverse();
             }
-            Address::Extended(ref mut value) => {
+            Address::Extended(mut value) => {
                 value.reverse();
                 self.set_dst_addressing_mode(AddressingMode::Extended);
                 let data = &mut self.buffer.as_mut()[field::ADDRESSING];
-                data[2..2 + 8].copy_from_slice(value);
+                data[2..2 + 8].copy_from_slice(&value);
                 value.reverse();
             }
         }
@@ -683,7 +683,7 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Frame<T> {
 
     /// Set the source address.
     #[inline]
-    pub fn set_src_addr(&mut self, mut value: Address) {
+    pub fn set_src_addr(&mut self, value: Address) {
         let offset = match self.dst_addressing_mode() {
             AddressingMode::Absent => 0,
             AddressingMode::Short => 2,
@@ -695,18 +695,18 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Frame<T> {
 
         match value {
             Address::Absent => self.set_src_addressing_mode(AddressingMode::Absent),
-            Address::Short(ref mut value) => {
+            Address::Short(mut value) => {
                 value.reverse();
                 self.set_src_addressing_mode(AddressingMode::Short);
                 let data = &mut self.buffer.as_mut()[field::ADDRESSING];
-                data[offset..offset + 2].copy_from_slice(value);
+                data[offset..offset + 2].copy_from_slice(&value);
                 value.reverse();
             }
-            Address::Extended(ref mut value) => {
+            Address::Extended(mut value) => {
                 value.reverse();
                 self.set_src_addressing_mode(AddressingMode::Extended);
                 let data = &mut self.buffer.as_mut()[field::ADDRESSING];
-                data[offset..offset + 8].copy_from_slice(value);
+                data[offset..offset + 8].copy_from_slice(&value);
                 value.reverse();
             }
         }

src/wire/ip.rs

@@ -116,17 +116,17 @@ impl Address {
 
     /// Return an address as a sequence of octets, in big-endian.
     pub const fn as_bytes(&self) -> &[u8] {
-        match *self {
+        match self {
             #[cfg(feature = "proto-ipv4")]
-            Address::Ipv4(ref addr) => addr.as_bytes(),
+            Address::Ipv4(addr) => addr.as_bytes(),
             #[cfg(feature = "proto-ipv6")]
-            Address::Ipv6(ref addr) => addr.as_bytes(),
+            Address::Ipv6(addr) => addr.as_bytes(),
         }
     }
 
     /// Query whether the address is a valid unicast address.
     pub fn is_unicast(&self) -> bool {
-        match *self {
+        match self {
             #[cfg(feature = "proto-ipv4")]
             Address::Ipv4(addr) => addr.is_unicast(),
             #[cfg(feature = "proto-ipv6")]
@@ -136,7 +136,7 @@ impl Address {
 
     /// Query whether the address is a valid multicast address.
     pub const fn is_multicast(&self) -> bool {
-        match *self {
+        match self {
             #[cfg(feature = "proto-ipv4")]
             Address::Ipv4(addr) => addr.is_multicast(),
             #[cfg(feature = "proto-ipv6")]
@@ -146,7 +146,7 @@ impl Address {
 
     /// Query whether the address is the broadcast address.
     pub fn is_broadcast(&self) -> bool {
-        match *self {
+        match self {
             #[cfg(feature = "proto-ipv4")]
             Address::Ipv4(addr) => addr.is_broadcast(),
             #[cfg(feature = "proto-ipv6")]
@@ -156,7 +156,7 @@ impl Address {
 
     /// Query whether the address falls into the "unspecified" range.
     pub fn is_unspecified(&self) -> bool {
-        match *self {
+        match self {
             #[cfg(feature = "proto-ipv4")]
             Address::Ipv4(addr) => addr.is_unspecified(),
             #[cfg(feature = "proto-ipv6")]