diff --git a/kernel/src/net/socket/ip/datagram/mod.rs b/kernel/src/net/socket/ip/datagram/mod.rs
index 229c924ac..ed61544b8 100644
--- a/kernel/src/net/socket/ip/datagram/mod.rs
+++ b/kernel/src/net/socket/ip/datagram/mod.rs
@@ -10,13 +10,12 @@ use super::addr::UNSPECIFIED_LOCAL_ENDPOINT;
 use crate::{
     events::IoEvents,
     fs::utils::Inode,
-    match_sock_option_mut,
     net::{
         iface::is_broadcast_endpoint,
         socket::{
             ip::options::{IpOptionSet, SetIpLevelOption},
             new_pseudo_inode,
-            options::{Error as SocketError, SocketOption},
+            options::{macros::sock_option_mut, Error as SocketError, SocketOption},
             private::SocketPrivate,
             util::{
                 datagram_common::{select_remote_and_bind, Bound, Inner},
@@ -241,13 +240,13 @@ impl Socket for DatagramSocket {
     }
 
     fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
-        match_sock_option_mut!(option, {
-            socket_errors: SocketError => {
+        sock_option_mut!(match option {
+            socket_errors @ SocketError => {
                 // TODO: Support socket errors for UDP sockets
                 socket_errors.set(None);
                 return Ok(());
-            },
-            _ => ()
+            }
+            _ => (),
         });
 
         let inner = self.inner.read();
diff --git a/kernel/src/net/socket/ip/options.rs b/kernel/src/net/socket/ip/options.rs
index d7aea82a7..12da4b394 100644
--- a/kernel/src/net/socket/ip/options.rs
+++ b/kernel/src/net/socket/ip/options.rs
@@ -5,8 +5,11 @@ use core::num::NonZeroU8;
 use aster_bigtcp::socket::NeedIfacePoll;
 
 use crate::{
-    impl_socket_options, match_sock_option_mut, match_sock_option_ref,
-    net::socket::options::SocketOption, prelude::*,
+    net::socket::options::{
+        macros::{impl_socket_options, sock_option_mut, sock_option_ref},
+        SocketOption,
+    },
+    prelude::*,
 };
 
 /// IP-level socket options.
@@ -43,24 +46,24 @@ impl IpOptionSet {
     }
 
     pub(super) fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
-        match_sock_option_mut!(option, {
-            ip_tos: Tos => {
+        sock_option_mut!(match option {
+            ip_tos @ Tos => {
                 let tos = self.tos();
                 ip_tos.set(tos as _);
-            },
-            ip_ttl: Ttl => {
+            }
+            ip_ttl @ Ttl => {
                 let ttl = self.ttl();
                 ip_ttl.set(ttl);
-            },
-            ip_hdrincl: Hdrincl => {
+            }
+            ip_hdrincl @ Hdrincl => {
                 let hdrincl = self.hdrincl();
                 ip_hdrincl.set(hdrincl);
-            },
-            ip_recverr: Recverr => {
+            }
+            ip_recverr @ Recverr => {
                 let recverr = self.recverr();
                 ip_recverr.set(recverr);
-            },
-            _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option is unknown")
+            }
+            _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option is unknown"),
         });
 
         Ok(())
@@ -71,28 +74,31 @@ impl IpOptionSet {
         option: &dyn SocketOption,
         socket: &dyn SetIpLevelOption,
     ) -> Result<NeedIfacePoll> {
-        match_sock_option_ref!(option, {
-            ip_tos: Tos => {
+        sock_option_ref!(match option {
+            ip_tos @ Tos => {
                 let old_value = self.tos();
                 let mut val = *ip_tos.get().unwrap() as u8;
                 val &= !INET_ECN_MASK;
                 val |= old_value & INET_ECN_MASK;
                 self.set_tos(val);
-            },
-            ip_ttl: Ttl => {
+            }
+            ip_ttl @ Ttl => {
                 let ttl = ip_ttl.get().unwrap();
                 self.set_ttl(*ttl);
-            },
-            ip_hdrincl: Hdrincl => {
+            }
+            ip_hdrincl @ Hdrincl => {
                 let hdrincl = ip_hdrincl.get().unwrap();
                 socket.set_hdrincl(*hdrincl)?;
                 self.set_hdrincl(*hdrincl);
-            },
-            ip_recverr: Recverr => {
+            }
+            ip_recverr @ Recverr => {
                 let recverr = ip_recverr.get().unwrap();
                 self.set_recverr(*recverr);
-            },
-            _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
+            }
+            _ => return_errno_with_message!(
+                Errno::ENOPROTOOPT,
+                "the socket option to be set is unknown"
+            ),
         });
 
         Ok(NeedIfacePoll::FALSE)
diff --git a/kernel/src/net/socket/ip/stream/mod.rs b/kernel/src/net/socket/ip/stream/mod.rs
index 84460c3d7..ba0bd8d9c 100644
--- a/kernel/src/net/socket/ip/stream/mod.rs
+++ b/kernel/src/net/socket/ip/stream/mod.rs
@@ -26,12 +26,14 @@ use super::{
 use crate::{
     events::IoEvents,
     fs::{file_handle::FileLike, utils::Inode},
-    match_sock_option_mut, match_sock_option_ref,
     net::{
         iface::Iface,
         socket::{
             new_pseudo_inode,
-            options::{Error as SocketError, SocketOption},
+            options::{
+                macros::{sock_option_mut, sock_option_ref},
+                Error as SocketError, SocketOption,
+            },
             private::SocketPrivate,
             util::{
                 options::{GetSocketLevelOption, SetSocketLevelOption, SocketOptionSet},
@@ -588,12 +590,12 @@ impl Socket for StreamSocket {
     }
 
     fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
-        match_sock_option_mut!(option, {
-            socket_errors: SocketError => {
+        sock_option_mut!(match option {
+            socket_errors @ SocketError => {
                 socket_errors.set(self.test_and_clear_error());
                 return Ok(());
-            },
-            _ => ()
+            }
+            _ => (),
         });
 
         let state = self.read_updated_state();
@@ -614,12 +616,12 @@ impl Socket for StreamSocket {
         // Deal with TCP-level options
         // FIXME: Here we only return the previously set values, without actually
         // asking the underlying sockets for the real, effective values.
-        match_sock_option_mut!(option, {
-            tcp_no_delay: NoDelay => {
+        sock_option_mut!(match option {
+            tcp_no_delay @ NoDelay => {
                 let no_delay = options.tcp.no_delay();
                 tcp_no_delay.set(no_delay);
-            },
-            tcp_maxseg: MaxSegment => {
+            }
+            tcp_maxseg @ MaxSegment => {
                 const DEFAULT_MAX_SEGMEMT: u32 = 536;
                 // For an unconnected socket,
                 // older Linux versions (e.g., v6.0) return
@@ -633,37 +635,40 @@ impl Socket for StreamSocket {
                 } else {
                     tcp_maxseg.set(maxseg);
                 }
-            },
-            tcp_keep_idle: KeepIdle => {
+            }
+            tcp_keep_idle @ KeepIdle => {
                 let keep_idle = options.tcp.keep_idle();
                 tcp_keep_idle.set(keep_idle);
-            },
-            tcp_syn_cnt: SynCnt => {
+            }
+            tcp_syn_cnt @ SynCnt => {
                 let syn_cnt = options.tcp.syn_cnt();
                 tcp_syn_cnt.set(syn_cnt);
-            },
-            tcp_defer_accept: DeferAccept => {
+            }
+            tcp_defer_accept @ DeferAccept => {
                 let defer_accept = options.tcp.defer_accept();
                 let seconds = defer_accept.to_secs();
                 tcp_defer_accept.set(seconds);
-            },
-            tcp_window_clamp: WindowClamp => {
+            }
+            tcp_window_clamp @ WindowClamp => {
                 let window_clamp = options.tcp.window_clamp();
                 tcp_window_clamp.set(window_clamp);
-            },
-            tcp_congestion: Congestion => {
+            }
+            tcp_congestion @ Congestion => {
                 let congestion = options.tcp.congestion();
                 tcp_congestion.set(congestion);
-            },
-            tcp_user_timeout: UserTimeout => {
+            }
+            tcp_user_timeout @ UserTimeout => {
                 let user_timeout = options.tcp.user_timeout();
                 tcp_user_timeout.set(user_timeout);
-            },
-            tcp_inq: Inq => {
+            }
+            tcp_inq @ Inq => {
                 let inq = options.tcp.receive_inq();
                 tcp_inq.set(inq);
-            },
-            _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to get is unknown")
+            }
+            _ => return_errno_with_message!(
+                Errno::ENOPROTOOPT,
+                "the socket option to get is unknown"
+            ),
         });
 
         Ok(())
@@ -712,23 +717,28 @@ fn do_tcp_setsockopt(
     options: &mut OptionSet,
     state: &mut State,
 ) -> Result<NeedIfacePoll> {
-    match_sock_option_ref!(option, {
-        tcp_no_delay: NoDelay => {
+    sock_option_ref!(match option {
+        tcp_no_delay @ NoDelay => {
             let no_delay = tcp_no_delay.get().unwrap();
             options.tcp.set_no_delay(*no_delay);
-            state.set_raw_option(|raw_socket: &dyn RawTcpSetOption| raw_socket.set_nagle_enabled(!no_delay));
-        },
-        tcp_maxseg: MaxSegment => {
+            state.set_raw_option(|raw_socket: &dyn RawTcpSetOption| {
+                raw_socket.set_nagle_enabled(!no_delay)
+            });
+        }
+        tcp_maxseg @ MaxSegment => {
             const MIN_MAXSEG: u32 = 536;
             const MAX_MAXSEG: u32 = 65535;
 
             let maxseg = tcp_maxseg.get().unwrap();
             if *maxseg < MIN_MAXSEG || *maxseg > MAX_MAXSEG {
-                return_errno_with_message!(Errno::EINVAL, "the maximum segment size is out of bounds");
+                return_errno_with_message!(
+                    Errno::EINVAL,
+                    "the maximum segment size is out of bounds"
+                );
             }
             options.tcp.set_maxseg(*maxseg);
-        },
-        tcp_keep_idle: KeepIdle => {
+        }
+        tcp_keep_idle @ KeepIdle => {
             const MIN_KEEP_IDLE: u32 = 1;
             const MAX_KEEP_IDLE: u32 = 32767;
 
@@ -739,8 +749,8 @@ fn do_tcp_setsockopt(
             options.tcp.set_keep_idle(*keepidle);
 
             // TODO: Track when the socket becomes idle to actually support keep idle.
-        },
-        tcp_syn_cnt: SynCnt => {
+        }
+        tcp_syn_cnt @ SynCnt => {
             const MAX_TCP_SYN_CNT: u8 = 127;
 
             let syncnt = tcp_syn_cnt.get().unwrap();
@@ -748,16 +758,16 @@ fn do_tcp_setsockopt(
                 return_errno_with_message!(Errno::EINVAL, "the SYN count is out of bounds");
             }
             options.tcp.set_syn_cnt(*syncnt);
-        },
-        tcp_defer_accept: DeferAccept => {
+        }
+        tcp_defer_accept @ DeferAccept => {
             let mut seconds = *(tcp_defer_accept.get().unwrap());
             if (seconds as i32) < 0 {
                 seconds = 0;
             }
             let retrans = Retrans::from_secs(seconds);
             options.tcp.set_defer_accept(retrans);
-        },
-        tcp_window_clamp: WindowClamp => {
+        }
+        tcp_window_clamp @ WindowClamp => {
             let window_clamp = tcp_window_clamp.get().unwrap();
             let half_recv_buf = options.socket.recv_buf() / 2;
             if *window_clamp <= half_recv_buf {
@@ -765,23 +775,24 @@ fn do_tcp_setsockopt(
             } else {
                 options.tcp.set_window_clamp(*window_clamp);
             }
-        },
-        tcp_congestion: Congestion => {
+        }
+        tcp_congestion @ Congestion => {
             let congestion = tcp_congestion.get().unwrap();
             options.tcp.set_congestion(*congestion);
-        },
-        tcp_user_timeout: UserTimeout => {
+        }
+        tcp_user_timeout @ UserTimeout => {
             let user_timeout = tcp_user_timeout.get().unwrap();
             if (*user_timeout as i32) < 0 {
                 return_errno_with_message!(Errno::EINVAL, "the user timeout cannot be negative");
             }
             options.tcp.set_user_timeout(*user_timeout);
-        },
-        tcp_inq: Inq => {
+        }
+        tcp_inq @ Inq => {
             let inq = tcp_inq.get().unwrap();
             options.tcp.set_receive_inq(*inq);
-        },
-        _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
+        }
+        _ =>
+            return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown"),
     });
 
     Ok(NeedIfacePoll::FALSE)
diff --git a/kernel/src/net/socket/ip/stream/options.rs b/kernel/src/net/socket/ip/stream/options.rs
index d43129fc6..4301b8a8e 100644
--- a/kernel/src/net/socket/ip/stream/options.rs
+++ b/kernel/src/net/socket/ip/stream/options.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use crate::{impl_socket_options, prelude::*};
+use crate::{net::socket::options::macros::impl_socket_options, prelude::*};
 
 impl_socket_options!(
     pub struct NoDelay(bool);
diff --git a/kernel/src/net/socket/netlink/common/mod.rs b/kernel/src/net/socket/netlink/common/mod.rs
index 25b292ce2..ba921fbd7 100644
--- a/kernel/src/net/socket/netlink/common/mod.rs
+++ b/kernel/src/net/socket/netlink/common/mod.rs
@@ -9,11 +9,13 @@ use super::{GroupIdSet, NetlinkSocketAddr};
 use crate::{
     events::IoEvents,
     fs::utils::Inode,
-    match_sock_option_mut, match_sock_option_ref,
     net::socket::{
         netlink::{table::SupportedNetlinkProtocol, AddMembership, DropMembership},
         new_pseudo_inode,
-        options::{Error as SocketError, SocketOption},
+        options::{
+            macros::{sock_option_mut, sock_option_ref},
+            Error as SocketError, SocketOption,
+        },
         private::SocketPrivate,
         util::{
             datagram_common::{select_remote_and_bind, Bound, Inner},
@@ -186,13 +188,13 @@ where
     }
 
     fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
-        match_sock_option_mut!(option, {
-            socket_errors: SocketError => {
+        sock_option_mut!(match option {
+            socket_errors @ SocketError => {
                 // TODO: Support socket errors for netlink sockets
                 socket_errors.set(None);
                 return Ok(());
-            },
-            _ => ()
+            }
+            _ => (),
         });
 
         let inner = self.inner.read();
@@ -281,16 +283,17 @@ fn do_netlink_setsockopt<P: SupportedNetlinkProtocol>(
     option: &dyn SocketOption,
     inner: &mut Inner<UnboundNetlink<P>, BoundNetlink<P::Message>>,
 ) -> Result<()> {
-    match_sock_option_ref!(option, {
-        add_membership: AddMembership => {
+    sock_option_ref!(match option {
+        add_membership @ AddMembership => {
             let groups = add_membership.get().unwrap();
             inner.add_groups(GroupIdSet::new(*groups));
-        },
-        drop_membership: DropMembership => {
+        }
+        drop_membership @ DropMembership => {
             let groups = drop_membership.get().unwrap();
             inner.drop_groups(GroupIdSet::new(*groups));
-        },
-        _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
+        }
+        _ =>
+            return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown"),
     });
 
     Ok(())
diff --git a/kernel/src/net/socket/netlink/options.rs b/kernel/src/net/socket/netlink/options.rs
index ac10b8fa5..0c9f9d8ba 100644
--- a/kernel/src/net/socket/netlink/options.rs
+++ b/kernel/src/net/socket/netlink/options.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use crate::impl_socket_options;
+use crate::net::socket::options::macros::impl_socket_options;
 
 impl_socket_options!(
     pub struct AddMembership(u32);
diff --git a/kernel/src/net/socket/options/macros.rs b/kernel/src/net/socket/options/macros.rs
index c81b4a321..9de5b52cd 100644
--- a/kernel/src/net/socket/options/macros.rs
+++ b/kernel/src/net/socket/options/macros.rs
@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: MPL-2.0
 
-#[macro_export]
 macro_rules! impl_socket_options {
     ($(
         $(#[$outer:meta])*
@@ -43,13 +42,13 @@ macro_rules! impl_socket_options {
         )*
     };
 }
+pub(in crate::net) use impl_socket_options;
 
-#[macro_export]
-macro_rules! match_sock_option_ref {
+macro_rules! sock_option_ref {
     (
-        $option:expr, {
-            $( $bind: ident : $ty:ty => $arm:expr ),*,
-            _ => $default:expr
+        match $option:ident {
+            $( $bind:ident @ $ty:ty => $arm:block $(,)? )*
+            _ => $default:expr $(,)?
         }
     ) => {{
         let __option : &dyn SocketOption = $option;
@@ -63,13 +62,13 @@ macro_rules! match_sock_option_ref {
         }
     }};
 }
+pub(in crate::net) use sock_option_ref;
 
-#[macro_export]
-macro_rules! match_sock_option_mut {
+macro_rules! sock_option_mut {
     (
-        $option:expr, {
-            $( $bind: ident : $ty:ty => $arm:expr ),*,
-            _ => $default:expr
+        match $option:ident {
+            $( $bind:ident @ $ty:ty => $arm:block $(,)? )*
+            _ => $default:expr $(,)?
         }
     ) => {{
         let __option : &mut dyn SocketOption = $option;
@@ -83,3 +82,4 @@ macro_rules! match_sock_option_mut {
         }
     }};
 }
+pub(in crate::net) use sock_option_mut;
diff --git a/kernel/src/net/socket/options/mod.rs b/kernel/src/net/socket/options/mod.rs
index 323c7c029..e72bd952e 100644
--- a/kernel/src/net/socket/options/mod.rs
+++ b/kernel/src/net/socket/options/mod.rs
@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use super::util::LingerOption;
-use crate::{impl_socket_options, net::socket::unix::CUserCred, prelude::*, process::Gid};
+use macros::impl_socket_options;
 
-mod macros;
+use super::util::LingerOption;
+use crate::{net::socket::unix::CUserCred, prelude::*, process::Gid};
+
+pub(in crate::net) mod macros;
 
 /// Socket options. This trait represents all options that can be set or got for a socket, including
 /// socket level options and options for specific socket type like tcp socket.
diff --git a/kernel/src/net/socket/unix/datagram/socket.rs b/kernel/src/net/socket/unix/datagram/socket.rs
index 4b14a5b88..ef72c33f5 100644
--- a/kernel/src/net/socket/unix/datagram/socket.rs
+++ b/kernel/src/net/socket/unix/datagram/socket.rs
@@ -6,10 +6,9 @@ use super::message::{MessageQueue, MessageReceiver};
 use crate::{
     events::IoEvents,
     fs::utils::Inode,
-    match_sock_option_mut,
     net::socket::{
         new_pseudo_inode,
-        options::{Error as SocketError, SocketOption},
+        options::{macros::sock_option_mut, Error as SocketError, SocketOption},
         private::SocketPrivate,
         unix::{ctrl_msg::AuxiliaryData, UnixSocketAddr},
         util::{
@@ -200,13 +199,13 @@ impl Socket for UnixDatagramSocket {
     }
 
     fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
-        match_sock_option_mut!(option, {
-            socket_errors: SocketError => {
+        sock_option_mut!(match option {
+            socket_errors @ SocketError => {
                 // TODO: Support socket errors for UNIX sockets
                 socket_errors.set(None);
                 return Ok(());
-            },
-            _ => ()
+            }
+            _ => (),
         });
 
         let options = self.options.read();
diff --git a/kernel/src/net/socket/unix/stream/socket.rs b/kernel/src/net/socket/unix/stream/socket.rs
index b7f74c499..fadfb8087 100644
--- a/kernel/src/net/socket/unix/stream/socket.rs
+++ b/kernel/src/net/socket/unix/stream/socket.rs
@@ -16,10 +16,11 @@ use crate::{
         file_handle::FileLike,
         utils::{EndpointState, Inode},
     },
-    match_sock_option_mut,
     net::socket::{
         new_pseudo_inode,
-        options::{Error as SocketError, PeerCred, PeerGroups, SocketOption},
+        options::{
+            macros::sock_option_mut, Error as SocketError, PeerCred, PeerGroups, SocketOption,
+        },
         private::SocketPrivate,
         unix::{cred::SocketCred, ctrl_msg::AuxiliaryData, CUserCred, UnixSocketAddr},
         util::{
@@ -387,13 +388,13 @@ impl Socket for UnixStreamSocket {
     }
 
     fn get_option(&self, option: &mut dyn SocketOption) -> Result<()> {
-        match_sock_option_mut!(option, {
-            socket_errors: SocketError => {
+        sock_option_mut!(match option {
+            socket_errors @ SocketError => {
                 // TODO: Support socket errors for UNIX sockets
                 socket_errors.set(None);
                 return Ok(());
-            },
-            _ => ()
+            }
+            _ => (),
         });
 
         let state = self.state.read();
@@ -496,19 +497,19 @@ impl Socket for UnixStreamSocket {
 }
 
 fn do_unix_getsockopt(option: &mut dyn SocketOption, state: &State) -> Result<()> {
-    match_sock_option_mut!(option, {
-        socket_peer_cred: PeerCred => {
+    sock_option_mut!(match option {
+        socket_peer_cred @ PeerCred => {
             let peer_cred = state.peer_cred().unwrap_or_else(CUserCred::new_invalid);
             socket_peer_cred.set(peer_cred);
-        },
-        socket_peer_groups: PeerGroups => {
+        }
+        socket_peer_groups @ PeerGroups => {
             let groups = state.peer_groups()?;
             socket_peer_groups.set(groups);
-        },
+        }
         _ => return_errno_with_message!(
             Errno::ENOPROTOOPT,
             "the socket option to get is not UNIX-socket-specific"
-        )
+        ),
     });
 
     Ok(())
diff --git a/kernel/src/net/socket/util/options.rs b/kernel/src/net/socket/util/options.rs
index 1e1d7f02a..b832a7391 100644
--- a/kernel/src/net/socket/util/options.rs
+++ b/kernel/src/net/socket/util/options.rs
@@ -8,10 +8,10 @@ use aster_bigtcp::socket::{
 
 use super::LingerOption;
 use crate::{
-    match_sock_option_mut, match_sock_option_ref,
     net::socket::{
         netlink::NETLINK_DEFAULT_BUF_SIZE,
         options::{
+            macros::{sock_option_mut, sock_option_ref},
             AcceptConn, Broadcast, KeepAlive, Linger, PassCred, PeerCred, PeerGroups, Priority,
             RecvBuf, RecvBufForce, ReuseAddr, ReusePort, SendBuf, SendBufForce, SocketOption,
         },
@@ -107,67 +107,70 @@ impl SocketOptionSet {
         option: &mut dyn SocketOption,
         socket: &dyn GetSocketLevelOption,
     ) -> Result<()> {
-        match_sock_option_mut!(option, {
-            socket_reuse_addr: ReuseAddr => {
+        sock_option_mut!(match option {
+            socket_reuse_addr @ ReuseAddr => {
                 let reuse_addr = self.reuse_addr();
                 socket_reuse_addr.set(reuse_addr);
-            },
-            socket_broadcast: Broadcast => {
+            }
+            socket_broadcast @ Broadcast => {
                 let broadcast = self.broadcast();
                 socket_broadcast.set(broadcast);
-            },
-            socket_send_buf: SendBuf => {
+            }
+            socket_send_buf @ SendBuf => {
                 let send_buf = self.send_buf();
                 socket_send_buf.set(send_buf);
-            },
-            socket_recv_buf: RecvBuf => {
+            }
+            socket_recv_buf @ RecvBuf => {
                 let recv_buf = self.recv_buf();
                 socket_recv_buf.set(recv_buf);
-            },
-            socket_keepalive: KeepAlive => {
+            }
+            socket_keepalive @ KeepAlive => {
                 let keep_alive = self.keep_alive();
                 socket_keepalive.set(keep_alive);
-            },
-            socket_priority: Priority => {
+            }
+            socket_priority @ Priority => {
                 let priority = self.priority();
                 socket_priority.set(priority);
-            },
-            socket_linger: Linger => {
+            }
+            socket_linger @ Linger => {
                 let linger = self.linger();
                 socket_linger.set(linger);
-            },
-            socket_reuse_port: ReusePort => {
+            }
+            socket_reuse_port @ ReusePort => {
                 let reuse_port = self.reuse_port();
                 socket_reuse_port.set(reuse_port);
-            },
-            socket_pass_cred: PassCred => {
+            }
+            socket_pass_cred @ PassCred => {
                 // This option only affects UNIX sockets. However, it also works well with other
                 // sockets for setting and getting.
                 let pass_cred = self.pass_cred();
                 socket_pass_cred.set(pass_cred);
-            },
-            socket_peer_cred: PeerCred => {
+            }
+            socket_peer_cred @ PeerCred => {
                 let peer_cred = CUserCred::new_invalid();
                 socket_peer_cred.set(peer_cred);
-            },
-            socket_accept_conn: AcceptConn => {
+            }
+            socket_accept_conn @ AcceptConn => {
                 let is_listening = socket.is_listening();
                 socket_accept_conn.set(is_listening);
-            },
-            socket_sendbuf_force: SendBufForce => {
+            }
+            socket_sendbuf_force @ SendBufForce => {
                 check_current_privileged()?;
                 let send_buf = self.send_buf();
                 socket_sendbuf_force.set(send_buf);
-            },
-            socket_recvbuf_force: RecvBufForce => {
+            }
+            socket_recvbuf_force @ RecvBufForce => {
                 check_current_privileged()?;
                 let recv_buf = self.recv_buf();
                 socket_recvbuf_force.set(recv_buf);
-            },
-            _socket_peer_groups: PeerGroups => {
+            }
+            _socket_peer_groups @ PeerGroups => {
                 return_errno_with_message!(Errno::ENODATA, "the socket does not have peer groups");
-            },
-            _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to get is unknown")
+            }
+            _ => return_errno_with_message!(
+                Errno::ENOPROTOOPT,
+                "the socket option to get is unknown"
+            ),
         });
         Ok(())
     }
@@ -178,58 +181,58 @@ impl SocketOptionSet {
         option: &dyn SocketOption,
         socket: &dyn SetSocketLevelOption,
     ) -> Result<NeedIfacePoll> {
-        match_sock_option_ref!(option, {
-            socket_reuse_addr: ReuseAddr => {
+        sock_option_ref!(match option {
+            socket_reuse_addr @ ReuseAddr => {
                 let reuse_addr = socket_reuse_addr.get().unwrap();
                 self.set_reuse_addr(*reuse_addr);
                 socket.set_reuse_addr(*reuse_addr);
-            },
-            socket_broadcast: Broadcast => {
+            }
+            socket_broadcast @ Broadcast => {
                 let broadcast = socket_broadcast.get().unwrap();
                 self.set_broadcast(*broadcast);
-            },
-            socket_send_buf: SendBuf => {
+            }
+            socket_send_buf @ SendBuf => {
                 let send_buf = socket_send_buf.get().unwrap();
                 if *send_buf <= MIN_SENDBUF {
                     self.set_send_buf(MIN_SENDBUF);
                 } else {
                     self.set_send_buf(*send_buf);
                 }
-            },
-            socket_recv_buf: RecvBuf => {
+            }
+            socket_recv_buf @ RecvBuf => {
                 let recv_buf = socket_recv_buf.get().unwrap();
                 if *recv_buf <= MIN_RECVBUF {
                     self.set_recv_buf(MIN_RECVBUF);
                 } else {
                     self.set_recv_buf(*recv_buf);
                 }
-            },
-            socket_keepalive: KeepAlive => {
+            }
+            socket_keepalive @ KeepAlive => {
                 let keep_alive = socket_keepalive.get().unwrap();
                 self.set_keep_alive(*keep_alive);
                 return Ok(socket.set_keep_alive(*keep_alive));
-            },
-            socket_priority: Priority => {
+            }
+            socket_priority @ Priority => {
                 let priority = socket_priority.get().unwrap();
                 check_priority(*priority)?;
                 self.set_priority(*priority);
-            },
-            socket_linger: Linger => {
+            }
+            socket_linger @ Linger => {
                 let linger = socket_linger.get().unwrap();
                 self.set_linger(*linger);
-            },
-            socket_reuse_port: ReusePort => {
+            }
+            socket_reuse_port @ ReusePort => {
                 let reuse_port = socket_reuse_port.get().unwrap();
                 self.set_reuse_port(*reuse_port);
-            },
-            socket_pass_cred: PassCred => {
+            }
+            socket_pass_cred @ PassCred => {
                 // This option only affects UNIX sockets. However, it also works well with other
                 // sockets for setting and getting.
                 let pass_cred = socket_pass_cred.get().unwrap();
                 self.set_pass_cred(*pass_cred);
                 socket.set_pass_cred(*pass_cred);
-            },
-            socket_sendbuf_force: SendBufForce => {
+            }
+            socket_sendbuf_force @ SendBufForce => {
                 check_current_privileged()?;
                 let send_buf = socket_sendbuf_force.get().unwrap();
                 if *send_buf <= MIN_SENDBUF {
@@ -237,8 +240,8 @@ impl SocketOptionSet {
                 } else {
                     self.set_send_buf(*send_buf);
                 }
-            },
-            socket_recvbuf_force: RecvBufForce => {
+            }
+            socket_recvbuf_force @ RecvBufForce => {
                 check_current_privileged()?;
                 let recv_buf = socket_recvbuf_force.get().unwrap();
                 if *recv_buf <= MIN_RECVBUF {
@@ -246,8 +249,11 @@ impl SocketOptionSet {
                 } else {
                     self.set_recv_buf(*recv_buf);
                 }
-            },
-            _ => return_errno_with_message!(Errno::ENOPROTOOPT, "the socket option to be set is unknown")
+            }
+            _ => return_errno_with_message!(
+                Errno::ENOPROTOOPT,
+                "the socket option to be set is unknown"
+            ),
         });
 
         Ok(NeedIfacePoll::FALSE)