Extract internal CachedSel and CachedClass types to simplify macros

Author: SSheldon

src/cache.rs

@@ -0,0 +1,66 @@
+use std::os::raw::c_void;
+use std::ptr;
+use std::sync::atomic::{AtomicPtr, Ordering};
+
+use crate::runtime::{Class, Sel, self};
+
+/// Allows storing a `Sel` in a static and lazily loading it.
+#[doc(hidden)]
+pub struct CachedSel {
+    ptr: AtomicPtr<c_void>
+}
+
+impl CachedSel {
+    /// Constructs a new `CachedSel`.
+    pub const fn new() -> CachedSel {
+        CachedSel {
+            ptr: AtomicPtr::new(ptr::null_mut())
+        }
+    }
+
+    /// Returns the cached selector. If no selector is yet cached, registers
+    /// one with the given name and stores it.
+    #[inline(always)]
+    pub unsafe fn get(&self, name: &str) -> Sel {
+        let ptr = self.ptr.load(Ordering::Relaxed);
+        // It should be fine to use `Relaxed` ordering here because `sel_registerName` is
+        // thread-safe.
+        if ptr.is_null() {
+            let sel = runtime::sel_registerName(name.as_ptr() as *const _);
+            self.ptr.store(sel.as_ptr() as *mut _, Ordering::Relaxed);
+            sel
+        } else {
+            Sel::from_ptr(ptr)
+        }
+    }
+}
+
+/// Allows storing a `Class` reference in a static and lazily loading it.
+#[doc(hidden)]
+pub struct CachedClass {
+    ptr: AtomicPtr<Class>
+}
+
+impl CachedClass {
+    /// Constructs a new `CachedClass`.
+    pub const fn new() -> CachedClass {
+        CachedClass {
+            ptr: AtomicPtr::new(ptr::null_mut())
+        }
+    }
+
+    /// Returns the cached class. If no class is yet cached, gets one with
+    /// the given name and stores it.
+    #[inline(always)]
+    pub unsafe fn get(&self, name: &str) -> Option<&'static Class> {
+        // `Relaxed` should be fine since `objc_getClass` is thread-safe.
+        let ptr = self.ptr.load(Ordering::Relaxed);
+        if ptr.is_null() {
+            let cls = runtime::objc_getClass(name.as_ptr() as *const _);
+            self.ptr.store(cls as *mut _, Ordering::Relaxed);
+            cls.as_ref()
+        } else {
+            Some(&*ptr)
+        }
+    }
+}

src/lib.rs

@@ -75,6 +75,8 @@ pub use objc_encode::{Encode, Encoding};
 pub use crate::encode::EncodeArguments;
 pub use crate::message::{Message, MessageArguments, MessageError};
 
+pub use crate::cache::CachedClass as __CachedClass;
+pub use crate::cache::CachedSel as __CachedSel;
 pub use crate::message::send_message as __send_message;
 pub use crate::message::send_super_message as __send_super_message;
 
@@ -84,6 +86,7 @@ mod macros;
 pub mod runtime;
 pub mod declare;
 pub mod rc;
+mod cache;
 mod encode;
 #[cfg(feature = "exception")]
 mod exception;

src/macros.rs

@@ -15,56 +15,17 @@ let cls = class!(NSObject);
 #[macro_export]
 macro_rules! class {
     ($name:ident) => ({
-        #[allow(deprecated)]
-        #[inline(always)]
-        fn get_class(name: &str) -> Option<&'static $crate::runtime::Class> {
-            unsafe {
-                static CLASS: ::std::sync::atomic::AtomicUsize = ::std::sync::atomic::AtomicUsize::new(0);
-                // `Relaxed` should be fine since `objc_getClass` is thread-safe.
-                let ptr = CLASS.load(::std::sync::atomic::Ordering::Relaxed) as *const $crate::runtime::Class;
-                if ptr.is_null() {
-                    let cls = $crate::runtime::objc_getClass(name.as_ptr() as *const _);
-                    CLASS.store(cls as usize, ::std::sync::atomic::Ordering::Relaxed);
-                    if cls.is_null() { None } else { Some(&*cls) }
-                } else {
-                    Some(&*ptr)
-                }
-            }
-        }
-        match get_class(concat!(stringify!($name), '\0')) {
+        static CLASS: $crate::__CachedClass = $crate::__CachedClass::new();
+        let name = concat!(stringify!($name), '\0');
+        #[allow(unused_unsafe)]
+        let cls = unsafe { CLASS.get(name) };
+        match cls {
             Some(cls) => cls,
             None => panic!("Class with name {} could not be found", stringify!($name)),
         }
     })
 }
 
-#[doc(hidden)]
-#[macro_export]
-macro_rules! sel_impl {
-    // Declare a function to hide unsafety, otherwise we can trigger the
-    // unused_unsafe lint; see rust-lang/rust#8472
-    ($name:expr) => ({
-        #[allow(deprecated)]
-        #[inline(always)]
-        fn register_sel(name: &str) -> $crate::runtime::Sel {
-            unsafe {
-                static SEL: ::std::sync::atomic::AtomicUsize = ::std::sync::atomic::AtomicUsize::new(0);
-                let ptr = SEL.load(::std::sync::atomic::Ordering::Relaxed) as *const ::std::os::raw::c_void;
-                // It should be fine to use `Relaxed` ordering here because `sel_registerName` is
-                // thread-safe.
-                if ptr.is_null() {
-                    let sel = $crate::runtime::sel_registerName(name.as_ptr() as *const _);
-                    SEL.store(sel.as_ptr() as usize, ::std::sync::atomic::Ordering::Relaxed);
-                    sel
-                } else {
-                    $crate::runtime::Sel::from_ptr(ptr)
-                }
-            }
-        }
-        register_sel($name)
-    })
-}
-
 /**
 Registers a selector, returning a `Sel`.
 
@@ -79,8 +40,18 @@ let sel = sel!(setObject:forKey:);
 */
 #[macro_export]
 macro_rules! sel {
-    ($name:ident) => ({$crate::sel_impl!(concat!(stringify!($name), '\0'))});
-    ($($name:ident :)+) => ({$crate::sel_impl!(concat!($(stringify!($name), ':'),+, '\0'))});
+    ($name:ident) => ({
+        static SEL: $crate::__CachedSel = $crate::__CachedSel::new();
+        let name = concat!(stringify!($name), '\0');
+        #[allow(unused_unsafe)]
+        unsafe { SEL.get(name) }
+    });
+    ($($name:ident :)+) => ({
+        static SEL: $crate::__CachedSel = $crate::__CachedSel::new();
+        let name = concat!($(stringify!($name), ':'),+, '\0');
+        #[allow(unused_unsafe)]
+        unsafe { SEL.get(name) }
+    });
 }
 
 /**