Merge pull request #88 from rust-embedded-community/feature/ci

Addressing clippy lints

Author: eldruin

src/bus.rs

@@ -211,7 +211,7 @@ impl<B: UsbBus> UsbBusAllocator<B> {
     ///
     /// This directly delegates to [`UsbBus::alloc_ep`], so see that method for details. In most
     /// cases classes should call the endpoint type specific methods instead.
-    pub fn alloc<'a, D: EndpointDirection>(
+    pub fn alloc<D: EndpointDirection>(
         &self,
         ep_addr: Option<EndpointAddress>,
         ep_type: EndpointType,

src/control_pipe.rs

@@ -51,10 +51,10 @@ impl<B: UsbBus> ControlPipe<'_, B> {
     }
 
     pub fn waiting_for_response(&self) -> bool {
-        match self.state {
-            ControlState::CompleteOut | ControlState::CompleteIn(_) => true,
-            _ => false,
-        }
+        matches!(
+            self.state,
+            ControlState::CompleteOut | ControlState::CompleteIn(_)
+        )
     }
 
     pub fn data(&self) -> &[u8] {
@@ -65,7 +65,7 @@ impl<B: UsbBus> ControlPipe<'_, B> {
         self.state = ControlState::Idle;
     }
 
-    pub fn handle_setup<'p>(&'p mut self) -> Option<Request> {
+    pub fn handle_setup(&mut self) -> Option<Request> {
         let count = match self.ep_out.read(&mut self.buf[..]) {
             Ok(count) => count,
             Err(UsbError::WouldBlock) => return None,
@@ -125,7 +125,7 @@ impl<B: UsbBus> ControlPipe<'_, B> {
         None
     }
 
-    pub fn handle_out<'p>(&'p mut self) -> Option<Request> {
+    pub fn handle_out(&mut self) -> Option<Request> {
         match self.state {
             ControlState::DataOut(req) => {
                 let i = self.i;

src/device.rs

@@ -295,8 +295,7 @@ impl<B: UsbBus> UsbDevice<'_, B> {
 
             match (req.recipient, req.request) {
                 (Recipient::Device, Request::GET_STATUS) => {
-                    let status: u16 = 0x0000
-                        | if self.self_powered { 0x0001 } else { 0x0000 }
+                    let status: u16 = if self.self_powered { 0x0001 } else { 0x0000 }
                         | if self.remote_wakeup_enabled {
                             0x0002
                         } else {
@@ -315,12 +314,11 @@ impl<B: UsbBus> UsbDevice<'_, B> {
                 (Recipient::Endpoint, Request::GET_STATUS) => {
                     let ep_addr = ((req.index as u8) & 0x8f).into();
 
-                    let status: u16 = 0x0000
-                        | if self.bus.is_stalled(ep_addr) {
-                            0x0001
-                        } else {
-                            0x0000
-                        };
+                    let status: u16 = if self.bus.is_stalled(ep_addr) {
+                        0x0001
+                    } else {
+                        0x0000
+                    };
 
                     xfer.accept_with(&status.to_le_bytes()).ok();
                 }

src/endpoint.rs

@@ -57,8 +57,8 @@ pub struct Endpoint<'a, B: UsbBus, D: EndpointDirection> {
 }
 
 impl<B: UsbBus, D: EndpointDirection> Endpoint<'_, B, D> {
-    pub(crate) fn new<'a>(
-        bus_ptr: &'a AtomicPtr<B>,
+    pub(crate) fn new(
+        bus_ptr: &AtomicPtr<B>,
         address: EndpointAddress,
         ep_type: EndpointType,
         max_packet_size: u16,

tests/test_class_host/device.rs

@@ -39,7 +39,7 @@ pub fn open_device(ctx: &Context) -> rusb::Result<DeviceHandles> {
         let mut handle = device.open()?;
 
         let langs = handle.read_languages(TIMEOUT)?;
-        if langs.len() == 0 || langs[0].lang_id() != EN_US {
+        if langs.is_empty() || langs[0].lang_id() != EN_US {
             continue;
         }
 

tests/test_class_host/tests.rs

@@ -38,7 +38,7 @@ fn control_request(dev, _out) {
     let data = random_data(rng.gen_range(0, 16));
 
     let mut expected = [0u8; 8];
-    expected[0] = (0x02 as u8) << 5;
+    expected[0] = 0x02_u8 << 5;
     expected[1] = test_class::REQ_STORE_REQUEST;
     expected[2..4].copy_from_slice(&value.to_le_bytes());
     expected[4..6].copy_from_slice(&index.to_le_bytes());
@@ -71,7 +71,7 @@ fn control_data(dev, _out) {
             dev.write_control(
                 request_type(Direction::Out, RequestType::Vendor, Recipient::Device),
                 test_class::REQ_WRITE_BUFFER, 0, 0,
-                &data, TIMEOUT).expect(&format!("control write len {}", len)),
+                &data, TIMEOUT).unwrap_or_else(|_| panic!("control write len {}", len)),
             data.len());
 
         let mut response = vec![0u8; *len];
@@ -80,7 +80,7 @@ fn control_data(dev, _out) {
             dev.read_control(
                 request_type(Direction::In, RequestType::Vendor, Recipient::Device),
                 test_class::REQ_READ_BUFFER, 0, 0,
-                &mut response, TIMEOUT).expect(&format!("control read len {}", len)),
+                &mut response, TIMEOUT).unwrap_or_else(|_| panic!("control read len {}", len)),
             data.len());
 
         assert_eq!(&response, &data);
@@ -169,14 +169,14 @@ fn bulk_loopback(dev, _out) {
 
         assert_eq!(
             dev.write_bulk(0x01, &data, TIMEOUT)
-                .expect(&format!("bulk write len {}", len)),
+                .unwrap_or_else(|_| panic!("bulk write len {}", len)),
             data.len(),
             "bulk write len {}", len);
 
         if *len > 0 && *len % 64 == 0 {
             assert_eq!(
                 dev.write_bulk(0x01, &[], TIMEOUT)
-                    .expect(&format!("bulk write zero-length packet")),
+                    .expect("bulk write zero-length packet"),
                 0,
                 "bulk write zero-length packet");
         }
@@ -187,7 +187,7 @@ fn bulk_loopback(dev, _out) {
 
         assert_eq!(
             dev.read_bulk(0x81, &mut response, TIMEOUT)
-                .expect(&format!("bulk read len {}", len)),
+                .unwrap_or_else(|_| panic!("bulk read len {}", len)),
             data.len(),
             "bulk read len {}", len);
 
@@ -201,7 +201,7 @@ fn interrupt_loopback(dev, _out) {
 
         assert_eq!(
             dev.write_interrupt(0x02, &data, TIMEOUT)
-                .expect(&format!("interrupt write len {}", len)),
+                .unwrap_or_else(|_| panic!("interrupt write len {}", len)),
             data.len(),
             "interrupt write len {}", len);
 
@@ -211,7 +211,7 @@ fn interrupt_loopback(dev, _out) {
 
         assert_eq!(
             dev.read_interrupt(0x82, &mut response, TIMEOUT)
-                .expect(&format!("interrupt read len {}", len)),
+                .unwrap_or_else(|_| panic!("interrupt read len {}", len)),
             data.len(),
             "interrupt read len {}", len);
 
@@ -241,7 +241,7 @@ fn bench_bulk_read(dev, out) {
 
 }
 
-fn run_bench(dev: &DeviceHandles, out: &mut String, f: impl Fn(&mut [u8]) -> ()) {
+fn run_bench(dev: &DeviceHandles, out: &mut String, f: impl Fn(&mut [u8])) {
     const TRANSFER_BYTES: usize = 64 * 1024;
     const TRANSFERS: usize = 16;
     const TOTAL_BYTES: usize = TRANSFER_BYTES * TRANSFERS;