Merge pull request #3676 from tock/clippy-D-bool_comparison

ppannuto · web-flow · commit 4015ee72a6c5 · 2023-09-18T18:14:29.000Z
clippy: -D clippy::bool_comparison
diff --git a/capsules/core/src/adc.rs b/capsules/core/src/adc.rs
@@ -669,7 +669,7 @@ impl<'a> AdcVirtualized<'a> {
                 match self
                     .apps
                     .enter(processid, |app, _| {
-                        if app.pending_command == true {
+                        if app.pending_command {
                             Err(ErrorCode::BUSY)
                         } else {
                             app.pending_command = true;
diff --git a/capsules/core/src/rng.rs b/capsules/core/src/rng.rs
@@ -157,7 +157,7 @@ impl rng::Client for RngDriver<'_> {
             // Check if done switched to false. If it did, then that app
             // didn't get enough random, so there's no way there is more for
             // other apps.
-            if done == false {
+            if !done {
                 break;
             }
         }
diff --git a/capsules/core/src/virtualizers/virtual_alarm.rs b/capsules/core/src/virtualizers/virtual_alarm.rs
@@ -151,7 +151,7 @@ impl<'a, A: Alarm<'a>> Alarm<'a> for VirtualMuxAlarm<'a, A> {
         if enabled == 0 {
             //debug!("virtual_alarm: first alarm: set it.");
             self.mux.set_alarm(reference, dt);
-        } else if self.mux.firing.get() == false {
+        } else if !self.mux.firing.get() {
             // If firing is true, the mux will scan all the alarms after
             // firing and pick the soonest one so do not need to modify the
             // mux. Otherwise, this is an alarm
diff --git a/capsules/extra/src/app_flash_driver.rs b/capsules/extra/src/app_flash_driver.rs
@@ -134,7 +134,7 @@ impl<'a> AppFlash<'a> {
                         .unwrap_or(Err(ErrorCode::RESERVE))
                 } else {
                     // Queue this request for later.
-                    if app.pending_command == true {
+                    if app.pending_command {
                         Err(ErrorCode::NOMEM)
                     } else {
                         app.pending_command = true;
diff --git a/capsules/extra/src/fxos8700cq.rs b/capsules/extra/src/fxos8700cq.rs
@@ -313,7 +313,7 @@ impl I2CClient for Fxos8700cq<'_> {
                 }
             }
             State::ReadAccelWait => {
-                if self.interrupt_pin1.read() == false {
+                if !self.interrupt_pin1.read() {
                     // Sample is already ready.
                     self.interrupt_pin1.disable_interrupts();
                     buffer[0] = Registers::OutXMsb as u8;
diff --git a/capsules/extra/src/ninedof.rs b/capsules/extra/src/ninedof.rs
@@ -93,7 +93,7 @@ impl<'a> NineDof<'a> {
                     }
                     CommandReturn::from(value)
                 } else {
-                    if app.pending_command == true {
+                    if app.pending_command {
                         CommandReturn::failure(ErrorCode::BUSY)
                     } else {
                         app.pending_command = true;
diff --git a/capsules/extra/src/nonvolatile_storage_driver.rs b/capsules/extra/src/nonvolatile_storage_driver.rs
@@ -303,7 +303,7 @@ impl<'a> NonvolatileStorage<'a> {
                                 self.userspace_call_driver(command, offset, active_len)
                             } else {
                                 // Some app is using the storage, we must wait.
-                                if app.pending_command == true {
+                                if app.pending_command {
                                     // No more room in the queue, nowhere to store this
                                     // request.
                                     Err(ErrorCode::NOMEM)
@@ -341,7 +341,7 @@ impl<'a> NonvolatileStorage<'a> {
                                 _ => Err(ErrorCode::FAIL),
                             }
                         } else {
-                            if self.kernel_pending_command.get() == true {
+                            if self.kernel_pending_command.get() {
                                 Err(ErrorCode::NOMEM)
                             } else {
                                 self.kernel_pending_command.set(true);
diff --git a/capsules/extra/src/rf233.rs b/capsules/extra/src/rf233.rs
@@ -1078,7 +1078,7 @@ impl<'a, S: spi::SpiMasterDevice<'a>> RF233<'a, S> {
         // packet from being overwritten before reading it from the radio,
         // the driver needs to disable reception. This has to be done in the first
         // SPI operation.
-        if self.spi_busy.get() == false {
+        if !self.spi_busy.get() {
             if self.state.get() == InternalState::RX {
                 // We've received a complete frame; need to disable
                 // reception until we've read it out from RAM,
diff --git a/capsules/extra/src/screen.rs b/capsules/extra/src/screen.rs
@@ -143,7 +143,7 @@ impl<'a> Screen<'a> {
         match self
             .apps
             .enter(process_id, |app, _| {
-                if app.pending_command == true {
+                if app.pending_command {
                     CommandReturn::failure(ErrorCode::BUSY)
                 } else {
                     app.pending_command = true;
diff --git a/capsules/extra/src/sdcard.rs b/capsules/extra/src/sdcard.rs
@@ -1246,7 +1246,7 @@ impl<'a, A: hil::time::Alarm<'a>> SDCard<'a, A> {
         // if there is no detect pin, assume an sd card is installed
         self.detect_pin.get().map_or(true, |pin| {
             // sd card detection pin is active low
-            pin.read() == false
+            !pin.read()
         })
     }
 
diff --git a/capsules/extra/src/sht3x.rs b/capsules/extra/src/sht3x.rs
@@ -97,7 +97,7 @@ impl<'a, A: Alarm<'a>, I: i2c::I2CDevice> SHT3x<'a, A, I> {
     }
 
     fn read_humidity(&self) -> Result<(), ErrorCode> {
-        if self.read_hum.get() == true {
+        if self.read_hum.get() {
             Err(ErrorCode::BUSY)
         } else {
             if self.state.get() == State::Idle {
@@ -111,7 +111,7 @@ impl<'a, A: Alarm<'a>, I: i2c::I2CDevice> SHT3x<'a, A, I> {
     }
 
     fn read_temperature(&self) -> Result<(), ErrorCode> {
-        if self.read_temp.get() == true {
+        if self.read_temp.get() {
             Err(ErrorCode::BUSY)
         } else {
             if self.state.get() == State::Idle {
@@ -172,7 +172,7 @@ impl<'a, A: Alarm<'a>, I: i2c::I2CDevice> i2c::I2CClient for SHT3x<'a, A, I> {
 
                 match state {
                     State::ReadData => {
-                        if self.read_temp.get() == true {
+                        if self.read_temp.get() {
                             self.read_temp.set(false);
                             if crc8(&buffer[0..2]) == buffer[2] {
                                 let mut stemp = buffer[0] as u32;
@@ -185,7 +185,7 @@ impl<'a, A: Alarm<'a>, I: i2c::I2CDevice> i2c::I2CClient for SHT3x<'a, A, I> {
                                     .map(|cb| cb.callback(Err(ErrorCode::FAIL)));
                             }
                         }
-                        if self.read_hum.get() == true {
+                        if self.read_hum.get() {
                             self.read_hum.set(false);
                             if crc8(&buffer[3..5]) == buffer[5] {
                                 let mut shum = buffer[3] as u32;
@@ -211,12 +211,12 @@ impl<'a, A: Alarm<'a>, I: i2c::I2CDevice> i2c::I2CClient for SHT3x<'a, A, I> {
             Err(i2c_err) => {
                 self.buffer.replace(buffer);
                 self.i2c.disable();
-                if self.read_temp.get() == true {
+                if self.read_temp.get() {
                     self.read_temp.set(false);
                     self.temperature_client
                         .map(|cb| cb.callback(Err(i2c_err.into())));
                 }
-                if self.read_hum.get() == true {
+                if self.read_hum.get() {
                     self.read_hum.set(false);
                     self.humidity_client.map(|cb| cb.callback(usize::MAX));
                 }
diff --git a/capsules/extra/src/text_screen.rs b/capsules/extra/src/text_screen.rs
@@ -110,7 +110,7 @@ impl<'a> TextScreen<'a> {
                     app.command = command;
                     Ok(true)
                 } else {
-                    if app.pending_command == true {
+                    if app.pending_command {
                         Err(ErrorCode::BUSY)
                     } else {
                         app.pending_command = true;
diff --git a/chips/imxrt10xx/src/lpuart.rs b/chips/imxrt10xx/src/lpuart.rs
@@ -806,7 +806,7 @@ impl<'a> hil::uart::Configure for Lpuart<'a> {
         if params.baud_rate != 115200
             || params.stop_bits != hil::uart::StopBits::One
             || params.parity != hil::uart::Parity::None
-            || params.hw_flow_control != false
+            || params.hw_flow_control
             || params.width != hil::uart::Width::Eight
         {
             panic!(
diff --git a/chips/litex/src/uart.rs b/chips/litex/src/uart.rs
@@ -268,7 +268,7 @@ impl<'a, R: LiteXSoCRegisterConfiguration> LiteXUart<'a, R> {
         if progress < len {
             // If we haven't transmitted all data, we _must_ have
             // reached the fifo-limit
-            assert!(fifo_full == true);
+            assert!(fifo_full);
 
             // Place all information and buffers back for the next
             // call to `resume_tx`, triggered by an interrupt.
@@ -305,7 +305,7 @@ impl<R: LiteXSoCRegisterConfiguration> uart::Configure for LiteXUart<'_, R> {
             if params.width != uart::Width::Eight
                 || params.parity != uart::Parity::None
                 || params.stop_bits != uart::StopBits::One
-                || params.hw_flow_control == true
+                || params.hw_flow_control
             {
                 Err(ErrorCode::NOSUPPORT)
             } else if params.baud_rate == 0 || params.baud_rate > system_clock {
diff --git a/chips/lowrisc/src/hmac.rs b/chips/lowrisc/src/hmac.rs
@@ -225,7 +225,7 @@ impl Hmac<'_> {
             } else {
                 Ok(())
             };
-            if self.data_progress() == false {
+            if !self.data_progress() {
                 // False means we are done
                 self.client.map(move |client| {
                     self.data.take().map(|buf| match buf {
diff --git a/chips/lowrisc/src/virtual_otbn.rs b/chips/lowrisc/src/virtual_otbn.rs
@@ -43,7 +43,7 @@ impl<'a> VirtualMuxAccel<'a> {
 
     pub fn load_binary(&self, input: &[u8]) -> Result<(), ErrorCode> {
         // Check if any mux is enabled. If it isn't we enable it for us.
-        if self.mux.running.get() == false {
+        if !self.mux.running.get() {
             self.mux.running.set(true);
             self.mux.running_id.set(self.id);
             self.mux.accel.load_binary(input)
@@ -56,7 +56,7 @@ impl<'a> VirtualMuxAccel<'a> {
 
     pub fn load_data(&self, address: usize, data: &[u8]) -> Result<(), ErrorCode> {
         // Check if any mux is enabled. If it isn't we enable it for us.
-        if self.mux.running.get() == false {
+        if !self.mux.running.get() {
             self.mux.running.set(true);
             self.mux.running_id.set(self.id);
             self.mux.accel.load_data(address, data)
@@ -73,7 +73,7 @@ impl<'a> VirtualMuxAccel<'a> {
         output: &'static mut [u8],
     ) -> Result<(), (ErrorCode, &'static mut [u8])> {
         // Check if any mux is enabled. If it isn't we enable it for us.
-        if self.mux.running.get() == false {
+        if !self.mux.running.get() {
             self.mux.running.set(true);
             self.mux.running_id.set(self.id);
             self.mux.accel.run(address, output)
diff --git a/chips/nrf52/src/uart.rs b/chips/nrf52/src/uart.rs
@@ -479,7 +479,7 @@ impl<'a> uart::Configure for Uarte<'a> {
         if params.parity != uart::Parity::None {
             return Err(ErrorCode::NOSUPPORT);
         }
-        if params.hw_flow_control != false {
+        if params.hw_flow_control {
             return Err(ErrorCode::NOSUPPORT);
         }
 
diff --git a/chips/sam4l/src/acifc.rs b/chips/sam4l/src/acifc.rs
@@ -318,7 +318,7 @@ impl<'a> Acifc<'a> {
 
         // Make sure enabling was succesful
         let result = regs.ctrl.is_set(Control::EN);
-        if result == false {
+        if !result {
             debug!("Failed enabling analog comparator, are you sure the clock is enabled?");
         }
     }
diff --git a/chips/sam4l/src/i2c.rs b/chips/sam4l/src/i2c.rs
@@ -582,7 +582,7 @@ impl<'a> PeripheralManagement<TWIMClock> for I2CHw<'a> {
     }
 
     fn before_peripheral_access(&self, clock: &TWIMClock, _: &TWIMRegisters) {
-        if clock.is_enabled() == false {
+        if !clock.is_enabled() {
             clock.enable();
         }
     }
@@ -609,7 +609,7 @@ impl<'a> PeripheralManagement<TWISClock> for I2CHw<'a> {
     }
 
     fn before_peripheral_access(&self, clock: &TWISClock, _: &TWISRegisters) {
-        if clock.is_enabled() == false {
+        if !clock.is_enabled() {
             clock.enable();
         }
     }
diff --git a/chips/sam4l/src/usart.rs b/chips/sam4l/src/usart.rs
@@ -299,7 +299,7 @@ static IS_PANICING: AtomicBool = AtomicBool::new(false);
 
 impl<'a> USARTRegManager<'a> {
     fn real_new(usart: &'a USART) -> USARTRegManager<'a> {
-        if pm::is_clock_enabled(usart.clock) == false {
+        if !pm::is_clock_enabled(usart.clock) {
             pm::enable_clock(usart.clock);
         }
         let regs: &UsartRegisters = &*usart.registers;
diff --git a/chips/sifive/src/uart.rs b/chips/sifive/src/uart.rs
@@ -327,7 +327,7 @@ impl hil::uart::Configure for Uart<'_> {
         if params.parity != hil::uart::Parity::None {
             return Err(ErrorCode::NOSUPPORT);
         }
-        if params.hw_flow_control != false {
+        if params.hw_flow_control {
             return Err(ErrorCode::NOSUPPORT);
         }
 
diff --git a/chips/stm32f303xc/src/adc.rs b/chips/stm32f303xc/src/adc.rs
@@ -644,7 +644,7 @@ impl<'a> Adc<'a> {
     }
 
     fn sample_u32(&self, channel: u32) -> Result<(), ErrorCode> {
-        if self.sc_enabled.get() == false {
+        if !self.sc_enabled.get() {
             self.enable_special_channels();
         }
         if self.status.get() == ADCStatus::Idle {
diff --git a/chips/stm32f303xc/src/usart.rs b/chips/stm32f303xc/src/usart.rs
@@ -568,7 +568,7 @@ impl hil::uart::Configure for Usart<'_> {
         if params.baud_rate != 115200
             || params.stop_bits != hil::uart::StopBits::One
             || params.parity != hil::uart::Parity::None
-            || params.hw_flow_control != false
+            || params.hw_flow_control
             || params.width != hil::uart::Width::Eight
         {
             panic!(
diff --git a/chips/stm32f4xx/src/usart.rs b/chips/stm32f4xx/src/usart.rs
@@ -528,7 +528,7 @@ impl<'a, DMA: dma::StreamServer<'a>> hil::uart::Configure for Usart<'a, DMA> {
         if params.baud_rate != 115200
             || params.stop_bits != hil::uart::StopBits::One
             || params.parity != hil::uart::Parity::None
-            || params.hw_flow_control != false
+            || params.hw_flow_control
             || params.width != hil::uart::Width::Eight
         {
             panic!(
diff --git a/chips/swervolf-eh1/src/uart.rs b/chips/swervolf-eh1/src/uart.rs
@@ -104,7 +104,7 @@ impl hil::uart::Configure for Uart<'_> {
         if params.parity != hil::uart::Parity::None {
             return Err(ErrorCode::NOSUPPORT);
         }
-        if params.hw_flow_control != false {
+        if params.hw_flow_control {
             return Err(ErrorCode::NOSUPPORT);
         }
 
diff --git a/chips/virtio/src/queues/split_queue.rs b/chips/virtio/src/queues/split_queue.rs
@@ -506,7 +506,7 @@ impl<'a, 'b, const MAX_QUEUE_SIZE: usize> SplitVirtqueue<'a, 'b, MAX_QUEUE_SIZE>
     /// Set the underlying [`VirtIOTransport`]. This must be done prior to
     /// initialization.
     pub fn set_transport(&self, transport: &'a dyn VirtIOTransport) {
-        assert!(self.initialized.get() == false);
+        assert!(!self.initialized.get());
         self.transport.set(transport);
     }
 
@@ -886,15 +886,15 @@ impl<'a, 'b, const MAX_QUEUE_SIZE: usize> Virtqueue for SplitVirtqueue<'a, 'b, M
     }
 
     fn negotiate_queue_size(&self, max_elements: usize) -> usize {
-        assert!(self.initialized.get() == false);
+        assert!(!self.initialized.get());
         let negotiated = cmp::min(MAX_QUEUE_SIZE, max_elements);
         self.max_elements.set(negotiated);
         self.available_ring_state.reset(negotiated);
         negotiated
     }
 
     fn initialize(&self, queue_number: u32, _queue_elements: usize) {
-        assert!(self.initialized.get() == false);
+        assert!(!self.initialized.get());
 
         // The transport must be set prior to initialization:
         assert!(self.transport.is_some());
diff --git a/kernel/src/process_standard.rs b/kernel/src/process_standard.rs
@@ -470,7 +470,7 @@ impl<C: Chip> Process for ProcessStandard<'_, C> {
         // because this state means the process is ready to run and
         // will be started in a future core scheduler loop; terminate
         // allows the kernel to prevent this before it starts running.
-        if self.is_running() == false
+        if !self.is_running()
             && self.get_state() != State::Faulted
             && self.get_state() != State::CredentialsApproved
         {
diff --git a/tools/run_clippy.sh b/tools/run_clippy.sh
@@ -46,7 +46,6 @@ CLIPPY_ARGS_COMPLEXITY="
 -A clippy::manual-flatten
 
 
--A clippy::bool_comparison
 -A clippy::zero_prefixed_literal
 -A clippy::needless-if
 

Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ impl rng::Client for RngDriver<'_> {`
`157`	`157`	`// Check if done switched to false. If it did, then that app`
`158`	`158`	`// didn't get enough random, so there's no way there is more for`
`159`	`159`	`// other apps.`
`160`		`- if done == false {`
	`160`	`+ if !done {`
`161`	`161`	`break;`
`162`	`162`	`}`
`163`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ impl I2CClient for Fxos8700cq<'_> {`
`313`	`313`	`}`
`314`	`314`	`}`
`315`	`315`	`State::ReadAccelWait => {`
`316`		`- if self.interrupt_pin1.read() == false {`
	`316`	`+ if !self.interrupt_pin1.read() {`
`317`	`317`	`// Sample is already ready.`
`318`	`318`	`self.interrupt_pin1.disable_interrupts();`
`319`	`319`	`buffer[0] = Registers::OutXMsb as u8;`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ impl<'a> NineDof<'a> {`
`93`	`93`	`}`
`94`	`94`	`CommandReturn::from(value)`
`95`	`95`	`} else {`
`96`		`- if app.pending_command == true {`
	`96`	`+ if app.pending_command {`
`97`	`97`	`CommandReturn::failure(ErrorCode::BUSY)`
`98`	`98`	`} else {`
`99`	`99`	`app.pending_command = true;`
Original file line number	Diff line number	Diff line change
`@@ -1246,7 +1246,7 @@ impl<'a, A: hil::time::Alarm<'a>> SDCard<'a, A> {`
`1246`	`1246`	`// if there is no detect pin, assume an sd card is installed`
`1247`	`1247`	`self.detect_pin.get().map_or(true, \|pin\| {`
`1248`	`1248`	`// sd card detection pin is active low`
`1249`		`- pin.read() == false`
	`1249`	`+ !pin.read()`
`1250`	`1250`	`})`
`1251`	`1251`	`}`
`1252`	`1252`