Cleaning up clippy lints.

Author: Jonathan Pallant (42 Technology)

src/dtls.rs

@@ -160,7 +160,7 @@ impl DtlsSocket {
 					sin_len: core::mem::size_of::<sys::nrf_sockaddr_in>() as u8,
 					sin_family: sys::NRF_AF_INET as i32,
 					sin_port: htons(port),
-					sin_addr: dns_addr.sin_addr.clone(),
+					sin_addr: dns_addr.sin_addr,
 				};
 
 				debug!("Trying IP address {}", &crate::NrfSockAddrIn(connect_addr));

src/gnss.rs

@@ -50,7 +50,7 @@ pub enum GnssData {
 }
 
 /// Specifies which NMEA fields you want from the GNSS sub-system.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
 pub struct NmeaMask(u16);
 
 /// The specific fields you can enable or disable in an `NmeaMask`.
@@ -70,7 +70,7 @@ pub enum NmeaField {
 }
 
 /// Specifies which non-volatile fields you want to delete before starting the GNSS.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
 pub struct DeleteMask(u32);
 
 /// The specific fields you can enable or disable in a `DeleteMask`.

src/lib.rs

@@ -112,6 +112,18 @@ pub enum Error {
 	TooManySockets,
 }
 
+/// We need to wrap our heap so it's creatable at run-time and accessible from an ISR.
+///
+/// * The Mutex allows us to safely share the heap between interrupt routines
+///   and the main thread - and nrfxlib will definitely use the heap in an
+///   interrupt.
+/// * The RefCell lets us share and object and mutate it (but not at the same
+///   time)
+/// * The Option is because the `linked_list_allocator::empty()` function is not
+///   `const` yet and cannot be called here
+///
+type WrappedHeap = Mutex<RefCell<Option<Heap>>>;
+
 //******************************************************************************
 // Constants
 //******************************************************************************
@@ -124,30 +136,14 @@ pub enum Error {
 
 /// Our general heap.
 ///
-/// * The Mutex allows us to safely share the heap between interrupt routines
-///   and the main thread - and nrfxlib will definitely use the heap in an
-///   interrupt.
-/// * The RefCell lets us share and object and mutate it (but not at the same
-///   time)
-/// * The Option is because the `linked_list_allocator::empty()` function is not
-///   `const` yet and cannot be called here
-///
-/// We initialise it later a static variable as the backing store.
-static mut GENERIC_ALLOCATOR: Mutex<RefCell<Option<Heap>>> = Mutex::new(RefCell::new(None));
+/// We initialise it later with a static variable as the backing store.
+static LIBRARY_ALLOCATOR: WrappedHeap = Mutex::new(RefCell::new(None));
 
 /// Our transmit heap.
-///
-/// * The Mutex allows us to safely share the heap between interrupt routines
-///   and the main thread - and nrfxlib will definitely use the heap in an
-///   interrupt.
-/// * The RefCell lets us share and object and mutate it (but not at the same
-///   time)
-/// * The Option is because the `linked_list_allocator::empty()` function is not
-///   `const` yet and cannot be called here
-///
+
 /// We initalise this later using a special region of shared memory that can be
 /// seen by the Cortex-M33 and the modem CPU.
-static mut TX_ALLOCATOR: Mutex<RefCell<Option<Heap>>> = Mutex::new(RefCell::new(None));
+static TX_ALLOCATOR: WrappedHeap = Mutex::new(RefCell::new(None));
 
 //******************************************************************************
 // Macros
@@ -167,7 +163,7 @@ pub fn init() -> Result<(), Error> {
 		let heap_start = HEAP_MEMORY.as_ptr() as usize;
 		let heap_size = HEAP_MEMORY.len() * core::mem::size_of::<u32>();
 		cortex_m::interrupt::free(|cs| {
-			*GENERIC_ALLOCATOR.borrow(cs).borrow_mut() = Some(Heap::new(heap_start, heap_size))
+			*LIBRARY_ALLOCATOR.borrow(cs).borrow_mut() = Some(Heap::new(heap_start, heap_size))
 		});
 	}
 

src/raw.rs

@@ -306,31 +306,31 @@ impl<'a> SocketOption<'a> {
 	}
 }
 
-impl Into<i32> for SocketDomain {
-	fn into(self) -> i32 {
+impl From<SocketDomain> for i32 {
+	fn from(s: SocketDomain) -> i32 {
 		use SocketDomain::*;
-		match self {
+		match s {
 			Local => sys::NRF_AF_LOCAL as i32,
 			Lte => sys::NRF_AF_LTE as i32,
 			Inet => sys::NRF_AF_INET as i32,
 		}
 	}
 }
 
-impl Into<i32> for SocketType {
-	fn into(self) -> i32 {
+impl From<SocketType> for i32 {
+	fn from(s: SocketType) -> i32 {
 		use SocketType::*;
-		match self {
+		match s {
 			Stream => sys::NRF_SOCK_STREAM as i32,
 			Datagram => sys::NRF_SOCK_DGRAM as i32,
 		}
 	}
 }
 
-impl Into<i32> for SocketProtocol {
-	fn into(self) -> i32 {
+impl From<SocketProtocol> for i32 {
+	fn from(s: SocketProtocol) -> i32 {
 		use SocketProtocol::*;
-		match self {
+		match s {
 			At => sys::NRF_PROTO_AT as i32,
 			Tcp => sys::NRF_IPPROTO_TCP as i32,
 			Udp => sys::NRF_IPPROTO_UDP as i32,
@@ -408,19 +408,19 @@ impl<'a> PollEntry<'a> {
 /// let mut socket1 = AtSocket::new();
 /// let mut socket2 = GnssSocket::new();
 /// let mut poll_list = [
-/// 	PollEntry::new(&mut socket1, PollFlags::Read),
-/// 	PollEntry::new(&mut socket2, PollFlags::Read),
+///     PollEntry::new(&mut socket1, PollFlags::Read),
+///     PollEntry::new(&mut socket2, PollFlags::Read),
 /// ];
 /// match nrfxlib::poll(&mut poll_list, 100) {
-/// 	Ok(0) => {
-///		// Timeout
-/// 	}
-/// 	Ok(n) => {
-///		// One of the sockets is ready. See `poll_list[n].result()`.
-/// 	}
-/// 	Err(e) => {
-///		// An error occurred
-/// 	}
+///     Ok(0) => {
+///         // Timeout
+///     }
+///     Ok(n) => {
+///         // One of the sockets is ready. See `poll_list[n].result()`.
+///     }
+///     Err(e) => {
+///         // An error occurred
+///     }
 /// }
 /// ```
 pub fn poll(poll_list: &mut [PollEntry], timeout_ms: u16) -> Result<i32, Error> {
@@ -462,7 +462,7 @@ pub fn poll(poll_list: &mut [PollEntry], timeout_ms: u16) -> Result<i32, Error>
 
 pub(crate) fn htons(input: u16) -> u16 {
 	let top: u16 = (input >> 8) & 0xFF;
-	let bottom: u16 = (input >> 0) & 0xFF;
+	let bottom: u16 = input & 0xFF;
 	(bottom << 8) | top
 }
 

src/tcp.rs

@@ -114,7 +114,7 @@ impl TcpSocket {
 					sin_len: core::mem::size_of::<sys::nrf_sockaddr_in>() as u8,
 					sin_family: sys::NRF_AF_INET as i32,
 					sin_port: htons(port),
-					sin_addr: dns_addr.sin_addr.clone(),
+					sin_addr: dns_addr.sin_addr,
 				};
 
 				debug!("Trying IP address {}", &crate::NrfSockAddrIn(connect_addr));

src/tls.rs

@@ -173,7 +173,7 @@ impl TlsSocket {
 					sin_len: core::mem::size_of::<sys::nrf_sockaddr_in>() as u8,
 					sin_family: sys::NRF_AF_INET as i32,
 					sin_port: htons(port),
-					sin_addr: dns_addr.sin_addr.clone(),
+					sin_addr: dns_addr.sin_addr,
 				};
 
 				debug!("Trying IP address {}", &crate::NrfSockAddrIn(connect_addr));

src/udp.rs

@@ -118,7 +118,7 @@ impl UdpSocket {
 					sin_len: core::mem::size_of::<sys::nrf_sockaddr_in>() as u8,
 					sin_family: sys::NRF_AF_INET as i32,
 					sin_port: htons(port),
-					sin_addr: dns_addr.sin_addr.clone(),
+					sin_addr: dns_addr.sin_addr,
 				};
 
 				debug!("Trying IP address {}", &crate::NrfSockAddrIn(connect_addr));