fmt: make all macros macro_rules so scoping is consistent.

embassy-extras/src/fmt.rs

@@ -1,69 +1,170 @@
 #![macro_use]
-#![allow(clippy::module_inception)]
-#![allow(unused)]
+#![allow(unused_macros)]
 
 #[cfg(all(feature = "defmt", feature = "log"))]
 compile_error!("You may not enable both `defmt` and `log` features.");
 
-pub use fmt::*;
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::trace!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::trace!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($($x:tt)*) => {
+        {
+            #[cfg(fevature = "log")]
+            log::debug!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug!($($x)*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::info!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::info!($($x)*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::warn!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::warn!($($x)*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::error!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::error!($($x)*);
+        }
+    };
+}
 
 #[cfg(feature = "defmt")]
-mod fmt {
-    pub use defmt::{
-        assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
-        info, panic, todo, trace, unreachable, unwrap, warn,
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
     };
 }
 
-#[cfg(feature = "log")]
-mod fmt {
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-    pub use log::{debug, error, info, trace, warn};
-}
-
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
-
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-}
-
 #[cfg(not(feature = "defmt"))]
 macro_rules! unwrap {
     ($arg:expr) => {

embassy-extras/src/ring_buffer.rs

@@ -1,5 +1,3 @@
-use crate::fmt::assert;
-
 pub struct RingBuffer<'a> {
     buf: &'a mut [u8],
     start: usize,

embassy-net/src/config/dhcp.rs

@@ -4,7 +4,6 @@ use smoltcp::time::Instant;
 
 use super::*;
 use crate::device::LinkState;
-use crate::fmt::*;
 use crate::{Interface, SocketSet};
 
 pub struct DhcpConfigurator {

embassy-net/src/config/mod.rs

@@ -2,7 +2,6 @@ use heapless::Vec;
 use smoltcp::time::Instant;
 use smoltcp::wire::{Ipv4Address, Ipv4Cidr};
 
-use crate::fmt::*;
 use crate::{Interface, SocketSet};
 
 mod statik;

embassy-net/src/config/statik.rs

@@ -1,7 +1,6 @@
 use smoltcp::time::Instant;
 
 use super::*;
-use crate::fmt::*;
 use crate::{Interface, SocketSet};
 
 pub struct StaticConfigurator {

embassy-net/src/device.rs

@@ -3,7 +3,6 @@ use smoltcp::phy::Device as SmolDevice;
 use smoltcp::phy::DeviceCapabilities;
 use smoltcp::time::Instant as SmolInstant;
 
-use crate::fmt::*;
 use crate::packet_pool::PacketBoxExt;
 use crate::Result;
 use crate::{Packet, PacketBox, PacketBuf};

embassy-net/src/fmt.rs

@@ -1,74 +1,171 @@
 #![macro_use]
+#![allow(unused_macros)]
 
 #[cfg(all(feature = "defmt", feature = "log"))]
 compile_error!("You may not enable both `defmt` and `log` features.");
 
-pub use fmt::*;
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::trace!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::trace!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($($x:tt)*) => {
+        {
+            #[cfg(fevature = "log")]
+            log::debug!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug!($($x)*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::info!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::info!($($x)*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::warn!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::warn!($($x)*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::error!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::error!($($x)*);
+        }
+    };
+}
 
 #[cfg(feature = "defmt")]
-mod fmt {
-    pub use defmt::{
-        assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
-        info, panic, todo, trace, unreachable, unwrap, warn,
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
     };
 }
 
-#[cfg(feature = "log")]
-mod fmt {
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-    pub use log::{debug, error, info, trace, warn};
-}
-
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
-
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-
-    #[macro_export]
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-}
-
 #[cfg(not(feature = "defmt"))]
-#[macro_export]
 macro_rules! unwrap {
     ($arg:expr) => {
         match $crate::fmt::Try::into_result($arg) {

embassy-net/src/stack.rs

@@ -20,7 +20,6 @@ use smoltcp::wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr};
 use crate::config::Configurator;
 use crate::config::Event;
 use crate::device::{Device, DeviceAdapter, LinkState};
-use crate::fmt::*;
 use crate::{Interface, SocketSet};
 
 const ADDRESSES_LEN: usize = 1;

embassy-net/src/tcp_socket.rs

@@ -11,7 +11,6 @@ use smoltcp::time::Duration;
 use smoltcp::wire::IpEndpoint;
 
 use super::stack::Stack;
-use crate::fmt::*;
 use crate::{Error, Result};
 
 pub struct TcpSocket<'a> {

embassy-nrf/src/buffered_uarte.rs

@@ -11,7 +11,6 @@ use embassy_extras::peripheral::{PeripheralMutex, PeripheralState};
 use embassy_extras::ring_buffer::RingBuffer;
 use embassy_extras::{low_power_wait_until, unborrow};
 
-use crate::fmt::{panic, *};
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{OptionalPin as GpioOptionalPin, Pin as GpioPin};
 use crate::pac;

embassy-nrf/src/fmt.rs

@@ -1,69 +1,170 @@
 #![macro_use]
-#![allow(clippy::module_inception)]
-#![allow(unused)]
+#![allow(unused_macros)]
 
 #[cfg(all(feature = "defmt", feature = "log"))]
 compile_error!("You may not enable both `defmt` and `log` features.");
 
-pub use fmt::*;
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::trace!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::trace!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($($x:tt)*) => {
+        {
+            #[cfg(fevature = "log")]
+            log::debug!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug!($($x)*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::info!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::info!($($x)*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::warn!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::warn!($($x)*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::error!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::error!($($x)*);
+        }
+    };
+}
 
 #[cfg(feature = "defmt")]
-mod fmt {
-    pub use defmt::{
-        assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
-        info, panic, todo, trace, unreachable, unwrap, warn,
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
     };
 }
 
-#[cfg(feature = "log")]
-mod fmt {
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-    pub use log::{debug, error, info, trace, warn};
-}
-
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
-
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-}
-
 #[cfg(not(feature = "defmt"))]
 macro_rules! unwrap {
     ($arg:expr) => {

embassy-nrf/src/pwm.rs

@@ -6,7 +6,6 @@ use core::sync::atomic::{compiler_fence, Ordering};
 use embassy::util::Unborrow;
 use embassy_extras::unborrow;
 
-use crate::fmt::{unreachable, *};
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::OptionalPin as GpioOptionalPin;
 use crate::interrupt::Interrupt;

embassy-nrf/src/qspi.rs

@@ -10,7 +10,6 @@ use embassy::util::{AtomicWaker, DropBomb, Unborrow};
 use embassy_extras::unborrow;
 use futures::future::poll_fn;
 
-use crate::fmt::{assert, assert_eq, *};
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{self, Pin as GpioPin};
 use crate::pac;

embassy-nrf/src/spim.rs

@@ -11,10 +11,10 @@ use embassy_extras::unborrow;
 use futures::future::poll_fn;
 use traits::spi::FullDuplex;
 
+use crate::gpio;
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{OptionalPin, Pin as GpioPin};
 use crate::interrupt::Interrupt;
-use crate::{fmt::*, gpio};
 use crate::{pac, util::slice_in_ram_or};
 
 pub use embedded_hal::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};

embassy-nrf/src/twim.rs

@@ -18,10 +18,10 @@ use futures::future::poll_fn;
 use traits::i2c::I2c;
 
 use crate::chip::{EASY_DMA_SIZE, FORCE_COPY_BUFFER_SIZE};
+use crate::gpio;
 use crate::gpio::Pin as GpioPin;
 use crate::pac;
 use crate::util::{slice_in_ram, slice_in_ram_or};
-use crate::{fmt::*, gpio};
 
 pub enum Frequency {
     #[doc = "26738688: 100 kbps"]

embassy-nrf/src/uarte.rs

@@ -13,7 +13,6 @@ use embassy_extras::unborrow;
 use futures::future::poll_fn;
 
 use crate::chip::EASY_DMA_SIZE;
-use crate::fmt::{assert, panic, *};
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{self, OptionalPin as GpioOptionalPin, Pin as GpioPin};
 use crate::interrupt::Interrupt;

embassy-rp/src/dma.rs

@@ -1,6 +1,5 @@
 use core::sync::atomic::{compiler_fence, Ordering};
 
-use crate::fmt::assert;
 use crate::pac::dma::vals;
 use crate::{pac, peripherals};
 

embassy-rp/src/fmt.rs

@@ -1,74 +1,171 @@
 #![macro_use]
+#![allow(unused_macros)]
 
 #[cfg(all(feature = "defmt", feature = "log"))]
 compile_error!("You may not enable both `defmt` and `log` features.");
 
-pub use fmt::*;
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::trace!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::trace!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($($x:tt)*) => {
+        {
+            #[cfg(fevature = "log")]
+            log::debug!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug!($($x)*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::info!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::info!($($x)*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::warn!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::warn!($($x)*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::error!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::error!($($x)*);
+        }
+    };
+}
 
 #[cfg(feature = "defmt")]
-mod fmt {
-    pub use defmt::{
-        assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
-        info, panic, todo, trace, unreachable, unwrap, warn,
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
     };
 }
 
-#[cfg(feature = "log")]
-mod fmt {
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-    pub use log::{debug, error, info, trace, warn};
-}
-
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
-
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-
-    #[macro_export]
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    #[macro_export]
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-}
-
 #[cfg(not(feature = "defmt"))]
-#[macro_export]
 macro_rules! unwrap {
     ($arg:expr) => {
         match $crate::fmt::Try::into_result($arg) {

embassy-rp/src/pll.rs

@@ -1,4 +1,3 @@
-use crate::fmt::assert;
 use crate::pac;
 
 const XOSC_MHZ: u32 = 12;

embassy-stm32/src/dac/v2.rs

@@ -1,5 +1,4 @@
 use crate::dac::{DacPin, Instance};
-use crate::fmt::*;
 use crate::gpio::AnyPin;
 use crate::pac::dac;
 use core::marker::PhantomData;

embassy-stm32/src/dma/v2.rs

@@ -5,7 +5,6 @@ use embassy::util::AtomicWaker;
 use futures::future::poll_fn;
 
 use super::*;
-use crate::fmt::assert;
 use crate::interrupt;
 use crate::pac;
 use crate::pac::dma::{regs, vals};

embassy-stm32/src/fmt.rs

@@ -1,69 +1,170 @@
 #![macro_use]
-#![allow(clippy::module_inception)]
-#![allow(unused)]
+#![allow(unused_macros)]
 
 #[cfg(all(feature = "defmt", feature = "log"))]
 compile_error!("You may not enable both `defmt` and `log` features.");
 
-pub use fmt::*;
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::trace!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::trace!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($($x:tt)*) => {
+        {
+            #[cfg(fevature = "log")]
+            log::debug!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug!($($x)*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::info!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::info!($($x)*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::warn!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::warn!($($x)*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::error!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::error!($($x)*);
+        }
+    };
+}
 
 #[cfg(feature = "defmt")]
-mod fmt {
-    pub use defmt::{
-        assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
-        info, panic, todo, trace, unreachable, unwrap, warn,
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
     };
 }
 
-#[cfg(feature = "log")]
-mod fmt {
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-    pub use log::{debug, error, info, trace, warn};
-}
-
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
-
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-}
-
 #[cfg(not(feature = "defmt"))]
 macro_rules! unwrap {
     ($arg:expr) => {

embassy-stm32/src/rcc/h7/mod.rs

@@ -2,7 +2,6 @@ use core::marker::PhantomData;
 
 use embassy::util::Unborrow;
 
-use crate::fmt::{assert, panic};
 use crate::pac::rcc::vals::Timpre;
 use crate::pac::{DBGMCU, RCC, SYSCFG};
 use crate::peripherals;

embassy-stm32/src/rcc/h7/pll.rs

@@ -1,5 +1,4 @@
 use super::{Hertz, RCC};
-use crate::fmt::assert;
 
 const VCO_MIN: u32 = 150_000_000;
 const VCO_MAX: u32 = 420_000_000;

embassy-stm32/src/sdmmc/v2.rs

@@ -10,7 +10,6 @@ use embassy_extras::unborrow;
 use futures::future::poll_fn;
 use sdio_host::{BusWidth, CardCapacity, CardStatus, CurrentState, SDStatus, CID, CSD, OCR, SCR};
 
-use crate::fmt::*;
 use crate::interrupt::Interrupt;
 use crate::pac;
 use crate::pac::gpio::Gpio;
@@ -434,7 +433,7 @@ impl SdmmcInner {
                     BusWidth::One => 0,
                     BusWidth::Four => 1,
                     BusWidth::Eight => 2,
-                    _ => self::panic!("Invalid Bus Width"),
+                    _ => panic!("Invalid Bus Width"),
                 })
             });
 
@@ -637,7 +636,7 @@ impl SdmmcInner {
         direction: Dir,
         data_transfer_timeout: u32,
     ) {
-        self::assert!(block_size <= 14, "Block size up to 2^14 bytes");
+        assert!(block_size <= 14, "Block size up to 2^14 bytes");
         let regs = self.0;
 
         let dtdir = match direction {
@@ -678,7 +677,7 @@ impl SdmmcInner {
         // Enforce AHB and SDMMC_CK clock relation. See RM0433 Rev 7
         // Section 55.5.8
         let sdmmc_bus_bandwidth = new_clock.0 * (width as u32);
-        self::assert!(hclk.0 > 3 * sdmmc_bus_bandwidth / 32);
+        assert!(hclk.0 > 3 * sdmmc_bus_bandwidth / 32);
         *clock = new_clock;
 
         // NOTE(unsafe) We have exclusive access to the regblock

embassy/src/executor/mod.rs

@@ -9,7 +9,6 @@ mod timer_queue;
 mod util;
 mod waker;
 
-use crate::fmt::panic;
 use crate::interrupt::{Interrupt, InterruptExt};
 use crate::time::Alarm;
 

embassy/src/executor/waker.rs

@@ -24,7 +24,9 @@ pub(crate) unsafe fn from_task(p: NonNull<TaskHeader>) -> Waker {
 
 pub unsafe fn task_from_waker(waker: &Waker) -> NonNull<TaskHeader> {
     let hack: &WakerHack = mem::transmute(waker);
-    assert_eq!(hack.vtable, &VTABLE);
+    if hack.vtable != &VTABLE {
+        panic!("Found waker not created by the embassy executor. Consider enabling the `executor-agnostic` feature on the `embassy` crate.")
+    }
     NonNull::new_unchecked(hack.data as *mut TaskHeader)
 }
 

embassy/src/fmt.rs

@@ -1,69 +1,170 @@
 #![macro_use]
-#![allow(clippy::module_inception)]
-#![allow(unused)]
+#![allow(unused_macros)]
 
 #[cfg(all(feature = "defmt", feature = "log"))]
 compile_error!("You may not enable both `defmt` and `log` features.");
 
-pub use fmt::*;
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::trace!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::trace!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($($x:tt)*) => {
+        {
+            #[cfg(fevature = "log")]
+            log::debug!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug!($($x)*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::info!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::info!($($x)*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::warn!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::warn!($($x)*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($($x:tt)*) => {
+        {
+            #[cfg(feature = "log")]
+            log::error!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::error!($($x)*);
+        }
+    };
+}
 
 #[cfg(feature = "defmt")]
-mod fmt {
-    pub use defmt::{
-        assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
-        info, panic, todo, trace, unreachable, unwrap, warn,
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
     };
 }
 
-#[cfg(feature = "log")]
-mod fmt {
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-    pub use log::{debug, error, info, trace, warn};
-}
-
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
-
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
-    };
-
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
-}
-
 #[cfg(not(feature = "defmt"))]
 macro_rules! unwrap {
     ($arg:expr) => {

embassy/src/time/mod.rs

@@ -10,8 +10,6 @@ pub use duration::Duration;
 pub use instant::Instant;
 pub use traits::*;
 
-use crate::fmt::*;
-
 // TODO allow customizing, probably via Cargo features `tick-hz-32768` or something.
 pub const TICKS_PER_SECOND: u64 = 32768;
 

embassy/src/util/drop_bomb.rs

@@ -1,4 +1,3 @@
-use crate::fmt::panic;
 use core::mem;
 
 /// An explosive ordinance that panics if it is improperly disposed of.

embassy/src/util/mutex.rs

@@ -1,8 +1,6 @@
 use core::cell::UnsafeCell;
 use critical_section::CriticalSection;
 
-use crate::fmt::assert;
-
 /// A "mutex" based on critical sections
 ///
 /// # Safety

embassy/src/util/portal.rs

@@ -1,4 +1,3 @@
-use crate::fmt::panic;
 use core::cell::UnsafeCell;
 use core::mem;
 use core::mem::MaybeUninit;

embassy/src/util/signal.rs

@@ -9,7 +9,6 @@ use executor::raw::TaskHeader;
 use ptr::NonNull;
 
 use crate::executor;
-use crate::fmt::panic;
 use crate::interrupt::{Interrupt, InterruptExt};
 
 /// Synchronization primitive. Allows creating awaitable signals that may be passed between tasks.