Use #[non_exhaustive] instead of manual variant

.github/workflows/test.yml

@@ -11,11 +11,11 @@ jobs:
  continue-on-error: ${{ matrix.rust == 'nightly' }}
  strategy:
  matrix:
- # Test on stable, MSRV 1.36, and nightly.
+ # Test on stable, MSRV 1.40, and nightly.
  # Failure is permitted on nightly.
  rust:
  - stable
- - 1.36.0
+ - 1.40.0
  - nightly
 
  features:
@@ -57,11 +57,11 @@ jobs:
  continue-on-error: ${{ matrix.rust == 'nightly' }}
  strategy:
  matrix:
- # Test on stable, MSRV 1.36, and nightly.
+ # Test on stable, MSRV 1.40, and nightly.
  # Failure is permitted on nightly.
  rust:
  - stable
- - 1.36.0
+ - 1.40.0
  - nightly
 
  features:

README.md

@@ -6,7 +6,7 @@ include complicated compile-time computations, such as macro or type tricks, eve
 at cost of performance degradation.
 
 _smoltcp_ does not need heap allocation *at all*, is [extensively documented][docs],
-and compiles on stable Rust 1.36 and later.
+and compiles on stable Rust 1.40 and later.
 
 _smoltcp_ achieves [~Gbps of throughput](#examplesbenchmarkrs) when tested against
 the Linux TCP stack in loopback mode.

src/iface/ethernet.rs

@@ -678,7 +678,6 @@ impl<'b, 'c, 'e, DeviceT> Interface<'b, 'c, 'e, DeviceT>
  Socket::Tcp(ref mut socket) =>
  socket.dispatch(timestamp, &caps, |response|
  respond!(IpPacket::Tcp(response))),
- Socket::__Nonexhaustive(_) => unreachable!()
  };
 
  match (device_result, socket_result) {
@@ -800,7 +799,8 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
  .filter_map(
  |addr| match *addr {
  IpCidr::Ipv4(cidr) => Some(cidr.address()),
- _ => None,
+ #[cfg(feature = "proto-ipv6")]
+ IpCidr::Ipv6(_) => None
  })
  .next()
  }
@@ -886,8 +886,6 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
  Ok(None)
  }
  }
-
- _ => Err(Error::Unrecognized)
  }
  }
 
@@ -1253,7 +1251,6 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
  }
  }
  }
- _ => return Err(Error::Unrecognized),
  }
  }
  self.process_nxt_hdr(sockets, timestamp, ipv6_repr, hbh_repr.next_header,
@@ -1421,8 +1418,7 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
  };
  Ok(self.icmpv6_reply(ipv6_repr, icmpv6_reply_repr))
  },
- IpRepr::Unspecified { .. } |
- IpRepr::__Nonexhaustive => Err(Error::Unaddressable),
+ IpRepr::Unspecified { .. } => Err(Error::Unaddressable),
  }
  }
 
@@ -1467,7 +1463,6 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
  let dst_hardware_addr =
  match arp_repr {
  ArpRepr::EthernetIpv4 { target_hardware_addr, .. } => target_hardware_addr,
- _ => unreachable!()
  };
 
  self.dispatch_ethernet(tx_token, timestamp, arp_repr.buffer_len(), |mut frame| {
@@ -1555,8 +1550,6 @@ impl<'b, 'c, 'e> InterfaceInner<'b, 'c, 'e> {
  b[12], b[13],
  b[14], b[15],
  ])),
- IpAddress::__Nonexhaustive =>
- unreachable!()
  };
  if let Some(hardware_addr) = hardware_addr {
  return Ok((hardware_addr, tx_token))
@@ -1770,7 +1763,7 @@ mod test {
  impl phy::TxToken for MockTxToken {
  fn consume<R, F>(self, _: Instant, _: usize, _: F) -> Result<R>
  where F: FnOnce(&mut [u8]) -> Result<R> {
- Err(Error::__Nonexhaustive)
+ Err(Error::Unaddressable)
  }
  }
 

src/lib.rs

@@ -116,6 +116,7 @@ pub mod dhcp;
 
 /// The error type for the networking stack.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum Error {
  /// An operation cannot proceed because a buffer is empty or full.
  Exhausted,
@@ -148,9 +149,6 @@ pub enum Error {
  /// An incoming packet was recognized but contradicted internal state.
  /// E.g. a TCP packet addressed to a socket that doesn't exist.
  Dropped,
-
- #[doc(hidden)]
- __Nonexhaustive
 }
 
 /// The result type for the networking stack.
@@ -169,7 +167,6 @@ impl fmt::Display for Error {
  Error::Fragmented => write!(f, "fragmented packet"),
  Error::Malformed => write!(f, "malformed packet"),
  Error::Dropped => write!(f, "dropped by socket"),
- Error::__Nonexhaustive => unreachable!()
  }
  }
 }

src/socket/mod.rs

@@ -11,7 +11,6 @@ The interface implemented by this module uses explicit buffering: you decide on
 size for a buffer, allocate it, and let the networking stack use it.
 */
 
-use core::marker::PhantomData;
 use crate::time::Instant;
 
 mod meta;
@@ -91,8 +90,6 @@ pub enum Socket<'a> {
  Udp(UdpSocket<'a>),
  #[cfg(feature = "socket-tcp")]
  Tcp(TcpSocket<'a>),
- #[doc(hidden)]
- __Nonexhaustive(PhantomData<&'a ()>)
 }
 
 macro_rules! dispatch_socket {
@@ -112,7 +109,6 @@ macro_rules! dispatch_socket {
  &$( $mut_ )* Socket::Udp(ref $( $mut_ )* $socket) => $code,
  #[cfg(feature = "socket-tcp")]
  &$( $mut_ )* Socket::Tcp(ref $( $mut_ )* $socket) => $code,
- &$( $mut_ )* Socket::__Nonexhaustive(_) => unreachable!()
  }
  };
 }
@@ -154,9 +150,10 @@ macro_rules! from_socket {
  impl<'a> AnySocket<'a> for $socket {
  fn downcast<'c>(ref_: SocketRef<'c, Socket<'a>>) ->
  Option<SocketRef<'c, Self>> {
- match SocketRef::into_inner(ref_) {
- &mut Socket::$variant(ref mut socket) => Some(SocketRef::new(socket)),
- _ => None,
+ if let Socket::$variant(ref mut socket) = SocketRef::into_inner(ref_) {
+ Some(SocketRef::new(socket))
+ } else {
+ None
  }
  }
  }

src/socket/raw.rs

@@ -257,7 +257,6 @@ impl<'a> RawSocket<'a> {
  Ok((IpRepr::Ipv6(ipv6_repr), packet.payload()))
  }
  IpVersion::Unspecified => unreachable!(),
- IpVersion::__Nonexhaustive => unreachable!()
  }
  }
 

src/socket/set.rs

@@ -155,7 +155,6 @@ impl<'a, 'b: 'a> Set<'a, 'b> {
  } else {
  socket.close()
  },
- Socket::__Nonexhaustive(_) => unreachable!()
  }
  }
  if may_remove {

src/wire/arp.rs

@@ -252,6 +252,7 @@ use crate::wire::{EthernetAddress, Ipv4Address};
 
 /// A high-level representation of an Address Resolution Protocol packet.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[non_exhaustive]
 pub enum Repr {
  /// An Ethernet and IPv4 Address Resolution Protocol packet.
  EthernetIpv4 {
@@ -261,8 +262,6 @@ pub enum Repr {
  target_hardware_addr: EthernetAddress,
  target_protocol_addr: Ipv4Address
  },
- #[doc(hidden)]
- __Nonexhaustive
 }
 
 impl Repr {
@@ -292,7 +291,6 @@ impl Repr {
  pub fn buffer_len(&self) -> usize {
  match *self {
  Repr::EthernetIpv4 { .. } => field::TPA(6, 4).end,
- Repr::__Nonexhaustive => unreachable!()
  }
  }
 
@@ -314,7 +312,6 @@ impl Repr {
  packet.set_target_hardware_addr(target_hardware_addr.as_bytes());
  packet.set_target_protocol_addr(target_protocol_addr.as_bytes());
  },
- Repr::__Nonexhaustive => unreachable!()
  }
  }
 }
@@ -351,7 +348,6 @@ impl fmt::Display for Repr {
  target_hardware_addr, target_protocol_addr,
  operation)
  },
- Repr::__Nonexhaustive => unreachable!()
  }
  }
 }

src/wire/icmpv4.rs

@@ -366,6 +366,7 @@ impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
 
 /// A high-level representation of an Internet Control Message Protocol version 4 packet header.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[non_exhaustive]
 pub enum Repr<'a> {
  EchoRequest {
  ident: u16,
@@ -382,8 +383,6 @@ pub enum Repr<'a> {
  header: Ipv4Repr,
  data: &'a [u8]
  },
- #[doc(hidden)]
- __Nonexhaustive
 }
 
 impl<'a> Repr<'a> {
@@ -446,7 +445,6 @@ impl<'a> Repr<'a> {
  &Repr::DstUnreachable { header, data, .. } => {
  field::UNUSED.end + header.buffer_len() + data.len()
  }
- &Repr::__Nonexhaustive => unreachable!()
  }
  }
 
@@ -483,8 +481,6 @@ impl<'a> Repr<'a> {
  let payload = &mut ip_packet.into_inner()[header.buffer_len()..];
  payload.copy_from_slice(&data[..])
  }
-
- Repr::__Nonexhaustive => unreachable!()
  }
 
  if checksum_caps.icmpv4.tx() {
@@ -526,7 +522,6 @@ impl<'a> fmt::Display for Repr<'a> {
  Repr::DstUnreachable { reason, .. } =>
  write!(f, "ICMPv4 destination unreachable ({})",
  reason),
- Repr::__Nonexhaustive => unreachable!()
  }
  }
 }

src/wire/icmpv6.rs

@@ -503,6 +503,7 @@ impl<T: AsRef<[u8]>> AsRef<[u8]> for Packet<T> {
 
 /// A high-level representation of an Internet Control Message Protocol version 6 packet header.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[non_exhaustive]
 pub enum Repr<'a> {
  DstUnreachable {
  reason: DstUnreachable,
@@ -538,8 +539,6 @@ pub enum Repr<'a> {
  #[cfg(feature = "ethernet")]
  Ndisc(NdiscRepr<'a>),
  Mld(MldRepr<'a>),
- #[doc(hidden)]
- __Nonexhaustive
 }
 
 impl<'a> Repr<'a> {
@@ -647,7 +646,6 @@ impl<'a> Repr<'a> {
  &Repr::Mld(mld) => {
  mld.buffer_len()
  },
- &Repr::__Nonexhaustive => unreachable!()
  }
  }
 
@@ -720,8 +718,6 @@ impl<'a> Repr<'a> {
  Repr::Mld(mld) => {
  mld.emit(packet)
  },
-
- Repr::__Nonexhaustive => unreachable!(),
  }
 
  if checksum_caps.icmpv6.tx() {