Change ! in associated error types to Infallible

The `Never` helper still exists, because it is necessary to implement
traits such as Termination for `!`, but the public error types are
changed.

While this is a breaking change that was not preceded by a deprecation,
it is unlikely people match on the precise type (and all error
conversions should be implemented or implementable on both types).

src/adc.rs

@@ -1,4 +1,4 @@
-use crate::Never;
+use core::convert::Infallible;
 
 pub struct ADCLine(riot_sys::adc_t);
 
@@ -43,9 +43,9 @@ impl embedded_hal_0_2::adc::Channel<ADC> for ADCLine {
 }
 
 impl embedded_hal_0_2::adc::OneShot<ADC, i32, ADCLine> for ADC {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn read(&mut self, pin: &mut ADCLine) -> nb::Result<i32, Never> {
+    fn read(&mut self, pin: &mut ADCLine) -> nb::Result<i32, Infallible> {
         // Sorry, blocking still
         Ok(unsafe { riot_sys::adc_sample(pin.0, self.resolution) })
     }

src/gnrc/netreg.rs

@@ -25,7 +25,7 @@ type PktsnipPort = crate::msg::v2::SendPort<
 /// used once more (with the risk that messages from the old registration arrive in the new one,
 /// which is wrong correctness-wise but safe because it'll still be a pointer to a pktsnip).
 #[cfg(feature = "with_msg_v2")]
-pub fn register_for_messages<F: FnOnce() -> crate::Never>(
+pub fn register_for_messages<F: FnOnce() -> !>(
     grant: PktsnipPort,
     nettype: riot_sys::gnrc_nettype_t,
     demux_ctx: u32,

src/gpio/impl_0_2.rs

@@ -3,70 +3,70 @@ use super::*;
 use embedded_hal_0_2::digital::v2::{InputPin, OutputPin, ToggleableOutputPin};
 
 impl InputPin for InputGPIO {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn is_high(&self) -> Result<bool, Never> {
+    fn is_high(&self) -> Result<bool, Infallible> {
         Ok(unsafe { gpio_read(self.to_c()) } != 0)
     }
 
-    fn is_low(&self) -> Result<bool, Never> {
+    fn is_low(&self) -> Result<bool, Infallible> {
         Ok(unsafe { gpio_read(self.to_c()) } == 0)
     }
 }
 
 impl OutputPin for OutputGPIO {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn set_high(&mut self) -> Result<(), Never> {
+    fn set_high(&mut self) -> Result<(), Infallible> {
         unsafe { gpio_set(self.to_c()) };
         Ok(())
     }
 
-    fn set_low(&mut self) -> Result<(), Never> {
+    fn set_low(&mut self) -> Result<(), Infallible> {
         unsafe { gpio_clear(self.to_c()) };
         Ok(())
     }
 }
 
 impl ToggleableOutputPin for OutputGPIO {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn toggle(&mut self) -> Result<(), Never> {
+    fn toggle(&mut self) -> Result<(), Infallible> {
         unsafe { gpio_toggle(self.to_c()) };
         Ok(())
     }
 }
 
 impl InputPin for InOutGPIO {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn is_high(&self) -> Result<bool, Never> {
+    fn is_high(&self) -> Result<bool, Infallible> {
         Ok(unsafe { gpio_read(self.to_c()) } != 0)
     }
 
-    fn is_low(&self) -> Result<bool, Never> {
+    fn is_low(&self) -> Result<bool, Infallible> {
         Ok(unsafe { gpio_read(self.to_c()) } == 0)
     }
 }
 
 impl OutputPin for InOutGPIO {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn set_high(&mut self) -> Result<(), Never> {
+    fn set_high(&mut self) -> Result<(), Infallible> {
         unsafe { gpio_set(self.to_c()) };
         Ok(())
     }
 
-    fn set_low(&mut self) -> Result<(), Never> {
+    fn set_low(&mut self) -> Result<(), Infallible> {
         unsafe { gpio_clear(self.to_c()) };
         Ok(())
     }
 }
 
 impl ToggleableOutputPin for InOutGPIO {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn toggle(&mut self) -> Result<(), Never> {
+    fn toggle(&mut self) -> Result<(), Infallible> {
         unsafe { gpio_toggle(self.to_c()) };
         Ok(())
     }

src/gpio/mod.rs

@@ -10,7 +10,7 @@ mod impl_1;
 use riot_sys::{gpio_clear, gpio_mode_t, gpio_read, gpio_set, gpio_t, gpio_toggle, gpio_write};
 
 use crate::error::NegativeErrorExt;
-use crate::Never;
+use core::convert::Infallible;
 
 /// A Rust representation of RIOT's gpio_t, representing a single pin in no particular
 /// configuration.

src/led.rs

@@ -1,6 +1,6 @@
 //! Wrappers for the `LEDn_{ON,OFF,TOGGLE}` macros
 
-use crate::Never;
+use core::convert::Infallible;
 
 /// The Ith LED (calling the `LED<I>_{ON,OFF,TOGGLE}` macros).
 ///
@@ -21,7 +21,7 @@ impl<const I: u8> LED<I> {
 }
 
 impl<const I: u8> switch_hal::OutputSwitch for LED<I> {
-    type Error = Never;
+    type Error = Infallible;
 
     fn on(&mut self) -> Result<(), Self::Error> {
         use embedded_hal_0_2::digital::v2::OutputPin;
@@ -35,17 +35,17 @@ impl<const I: u8> switch_hal::OutputSwitch for LED<I> {
 }
 
 impl<const I: u8> switch_hal::ToggleableOutputSwitch for LED<I> {
-    type Error = Never;
+    type Error = Infallible;
 
     fn toggle(&mut self) -> Result<(), Self::Error> {
         <Self as embedded_hal_0_2::digital::v2::ToggleableOutputPin>::toggle(self)
     }
 }
 
 impl<const I: u8> embedded_hal_0_2::digital::v2::OutputPin for LED<I> {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn set_high(&mut self) -> Result<(), Never> {
+    fn set_high(&mut self) -> Result<(), Infallible> {
         // unsafe: RIOT's LED functions can be called any time (and no-op on undefined LEDs)
         unsafe {
             match I {
@@ -63,7 +63,7 @@ impl<const I: u8> embedded_hal_0_2::digital::v2::OutputPin for LED<I> {
         Ok(())
     }
 
-    fn set_low(&mut self) -> Result<(), Never> {
+    fn set_low(&mut self) -> Result<(), Infallible> {
         // unsafe: RIOT's LED functions can be called any time (and no-op on undefined LEDs)
         unsafe {
             match I {
@@ -83,9 +83,9 @@ impl<const I: u8> embedded_hal_0_2::digital::v2::OutputPin for LED<I> {
 }
 
 impl<const I: u8> embedded_hal_0_2::digital::v2::ToggleableOutputPin for LED<I> {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn toggle(&mut self) -> Result<(), Never> {
+    fn toggle(&mut self) -> Result<(), Infallible> {
         // unsafe: RIOT's LED functions can be called any time (and no-op on undefined LEDs)
         unsafe {
             match I {

src/lib.rs

@@ -38,7 +38,6 @@ pub mod error;
 
 mod helpers;
 mod never;
-use never::Never;
 
 /// The identifier of the RIOT board the program is being built for (`RIOT_BOARD` in C).
 #[doc(alias = "RIOT_BOARD")]

src/main_module.rs

@@ -56,9 +56,9 @@ impl<F: Fn() -> T, T: Termination> UsableAsMain<[u8; 1]> for F {
     }
 }
 
-impl<F: Fn(StartToken) -> crate::never::Never> Sealed<[u8; 2]> for F {}
+impl<F: Fn(StartToken) -> !> Sealed<[u8; 2]> for F {}
 
-impl<F: Fn(StartToken) -> crate::never::Never> UsableAsMain<[u8; 2]> for F {
+impl<F: Fn(StartToken) -> !> UsableAsMain<[u8; 2]> for F {
     unsafe fn call_main(&self) -> i32 {
         // unsafe: By construction of the C main function this only happens at startup time
         // with a thread that hasn't done anything relevant before.
@@ -144,12 +144,12 @@ impl<E: fmt::Debug> Termination for Result<(), E> {
     fn report(self) -> i32 {
         match self {
             Ok(()) => ().report(),
-            Err(err) => Err::<crate::Never, _>(err).report(),
+            Err(err) => Err::<crate::never::Never, _>(err).report(),
         }
     }
 }
 
-impl Termination for crate::Never {
+impl Termination for crate::never::Never {
     fn report(self) -> i32 {
         self
     }
@@ -161,7 +161,7 @@ impl Termination for core::convert::Infallible {
     }
 }
 
-impl<E: fmt::Debug> Termination for Result<crate::Never, E> {
+impl<E: fmt::Debug> Termination for Result<crate::never::Never, E> {
     fn report(self) -> i32 {
         match self {
             Err(err) => {

src/microbit.rs

@@ -6,7 +6,7 @@ use embedded_graphics::{
     drawable::Pixel, geometry::Point, geometry::Size, pixelcolor::BinaryColor, DrawTarget,
 };
 
-use crate::Never;
+use core::convert::Infallible;
 
 /// The 5x5 LED matrix of the micro:bit boards
 ///
@@ -24,9 +24,9 @@ impl LEDs {
 }
 
 impl DrawTarget<BinaryColor> for LEDs {
-    type Error = Never;
+    type Error = Infallible;
 
-    fn draw_pixel(&mut self, pixel: Pixel<BinaryColor>) -> Result<(), Never> {
+    fn draw_pixel(&mut self, pixel: Pixel<BinaryColor>) -> Result<(), Infallible> {
         let Pixel(Point { x, y }, color) = pixel;
 
         let setter = match color {

src/saul/registration.rs

@@ -14,7 +14,7 @@ use riot_sys::libc;
 
 use super::{Class, Phydat};
 use crate::error::NegativeErrorExt;
-use crate::Never;
+use core::convert::Infallible;
 
 /// The single error read and write operations may produce; corresponds to an `-ECANCELED`.
 /// (-ENOTSUP is expressed by not having support for the operation in the first place, indicated by
@@ -229,7 +229,7 @@ pub fn register_and_then<DEV, DRIV>(
     driver: &Driver<DEV, DRIV>,
     device: &DEV,
     name: Option<&CStr>,
-    f: impl FnOnce() -> Never,
+    f: impl FnOnce() -> !,
 ) -> !
 where
     DEV: Sized + Sync + 'static,

src/spi/mod.rs

@@ -1,4 +1,4 @@
-use crate::Never;
+use core::convert::Infallible;
 use embedded_hal_0_2::blocking;
 use riot_sys::{
     spi_acquire, spi_clk_t, spi_cs_t, spi_mode_t, spi_release, spi_t, spi_transfer_bytes,
@@ -65,7 +65,7 @@ impl SPIDevice {
 // }
 
 impl<'a> blocking::spi::Transfer<u8> for AcquiredSPI<'a> {
-    type Error = Never;
+    type Error = Infallible;
 
     fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
         unsafe {

src/thread/tokenparts.rs

@@ -147,10 +147,7 @@ impl<const MS: bool, const FS: bool> TokenParts<MS, true, FS> {
     // unsound: The `true` MS would mean that the NoConfiguredMessages could be taken out again and
     // used to configure semantics, and then all of a sudden the still-configured message queue
     // would be sent to again.
-    pub fn with_message_queue<
-        const N: usize,
-        F: FnOnce(TokenParts<MS, false, FS>) -> crate::Never,
-    >(
+    pub fn with_message_queue<const N: usize, F: FnOnce(TokenParts<MS, false, FS>) -> !>(
         self,
         f: F,
     ) -> ! {