fmt: make all macros `macro_rules` so scoping is consistent.

7 files changed, 146 insertions, 55 deletions

diff --git a/embassy-net/src/config/dhcp.rs b/embassy-net/src/config/dhcp.rs
index f0c144321..8bbcd8176 100644
--- a/embassy-net/src/config/dhcp.rs
+++ b/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 {
diff --git a/embassy-net/src/config/mod.rs b/embassy-net/src/config/mod.rs
index 94725dba6..0f1886ae8 100644
--- a/embassy-net/src/config/mod.rs
+++ b/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;
diff --git a/embassy-net/src/config/statik.rs b/embassy-net/src/config/statik.rs
index 912143bff..9a530717b 100644
--- a/embassy-net/src/config/statik.rs
+++ b/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 {
diff --git a/embassy-net/src/device.rs b/embassy-net/src/device.rs
index 6c06b0605..5fcb94ac8 100644
--- a/embassy-net/src/device.rs
+++ b/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};
diff --git a/embassy-net/src/fmt.rs b/embassy-net/src/fmt.rs
index 4da69766c..6c5063f7c 100644
--- a/embassy-net/src/fmt.rs
+++ b/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)*);
+        }
+    };
+}
 
-#[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! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_eq!($($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,
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::assert_ne!($($x)*);
+        }
     };
-    pub use log::{debug, error, info, trace, warn};
 }
 
-#[cfg(not(any(feature = "defmt", feature = "log")))]
-mod fmt {
-    #![macro_use]
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::debug_assert!($($x)*);
+        }
+    };
+}
 
-    pub use core::{
-        assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
-        unreachable,
+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_export]
-    macro_rules! trace {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
+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_export]
-    macro_rules! debug {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::todo!($($x)*);
+        }
+    };
+}
 
-    #[macro_export]
-    macro_rules! info {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::unreachable!($($x)*);
+        }
+    };
+}
 
-    #[macro_export]
-    macro_rules! warn {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            defmt::panic!($($x)*);
+        }
+    };
+}
 
-    #[macro_export]
-    macro_rules! error {
-        ($($msg:expr),+ $(,)?) => {
-            ()
-        };
-    }
+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")]
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        defmt::unwrap!($($x)*)
+    };
 }
 
 #[cfg(not(feature = "defmt"))]
-#[macro_export]
 macro_rules! unwrap {
     ($arg:expr) => {
         match $crate::fmt::Try::into_result($arg) {
diff --git a/embassy-net/src/stack.rs b/embassy-net/src/stack.rs
index e436beb1e..a38f00958 100644
--- a/embassy-net/src/stack.rs
+++ b/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;
diff --git a/embassy-net/src/tcp_socket.rs b/embassy-net/src/tcp_socket.rs
index 4f43bc611..def4c8176 100644
--- a/embassy-net/src/tcp_socket.rs
+++ b/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> {