add the unstable-darwin-objc feature

Author: jbatez

crates/header-translator/src/library.rs

@@ -232,6 +232,12 @@ impl Library {
             )?;
             writeln!(lib_rs, "//! [framework-crates]: https://docs.rs/objc2/latest/objc2/topics/about_generated/index.html")?;
             writeln!(lib_rs, "#![no_std]")?;
+            if !self.data.is_library {
+                writeln!(
+                    lib_rs,
+                    "#![cfg_attr(feature = \"unstable-darwin-objc\", feature(darwin_objc))]"
+                )?;
+            }
             writeln!(lib_rs, "#![cfg_attr(docsrs, feature(doc_auto_cfg))]")?;
             writeln!(lib_rs, "// Update in Cargo.toml as well.")?;
             writeln!(
@@ -447,6 +453,20 @@ see that for related crates.", self.data.krate)?;
             cargo_toml["features"][feature] = array_with_newlines(enabled_features);
         }
 
+        // Emit unstable-darwin-objc feature in framework crates.
+        //
+        // We could also use this to enable the feature automatically in
+        // dependencies, but we'd like for this feature to remain "unstable" in
+        // the sense that we'd be free to remove it in a patch release. By
+        // mentioning it across crates, that would no longer be the case.
+        //
+        // It's slightly less convenient for users, but in practice, most users
+        // already directly depend on all their `objc2-*` crates in their
+        // dependency tree.
+        if !self.data.is_library {
+            cargo_toml["features"]["unstable-darwin-objc"] = array_with_newlines([]);
+        }
+
         // And then the rest of the features.
         if !emitted_features.is_empty() {
             add_newline_at_end(&mut cargo_toml["features"]);

crates/objc2/Cargo.toml

@@ -80,6 +80,7 @@ verify = []
 #
 # Please test it, and report any issues you may find:
 # https://github.com/madsmtm/objc2/issues/new
+unstable-darwin-objc = []
 unstable-static-sel = ["dep:objc2-proc-macros"]
 unstable-static-sel-inlined = ["unstable-static-sel"]
 unstable-static-class = ["dep:objc2-proc-macros"]

crates/objc2/src/__macros/class.rs

@@ -27,9 +27,9 @@ use crate::runtime::AnyClass;
 ///
 /// # Features
 ///
-/// If the experimental `"unstable-static-class"` feature is enabled, this
-/// will emit special statics that will be replaced by dyld when the program
-/// starts up.
+/// If the experimental `"unstable-static-class"` or `"unstable-darwin-objc"`
+/// features are enabled, this will emit special statics that will be replaced
+/// by dyld when the program starts up.
 ///
 /// Errors that were previously runtime panics may now turn into linker errors
 /// if you try to use a class which is not available. Additionally, you may
@@ -78,7 +78,10 @@ macro_rules! class {
 
 #[doc(hidden)]
 #[macro_export]
-#[cfg(not(feature = "unstable-static-class"))]
+#[cfg(not(any(
+    feature = "unstable-darwin-objc",
+    feature = "unstable-static-class"
+)))]
 macro_rules! __class_inner {
     ($name:expr, $_hash:expr) => {{
         static CACHED_CLASS: $crate::__macros::CachedClass = $crate::__macros::CachedClass::new();
@@ -89,6 +92,22 @@ macro_rules! __class_inner {
     }};
 }
 
+#[doc(hidden)]
+#[macro_export]
+#[cfg(all(
+    feature = "unstable-darwin-objc",
+    not(feature = "unstable-static-class")
+))]
+macro_rules! __class_inner {
+    ($name:expr, $_hash:expr) => {{
+        let ptr = $crate::__macros::core_darwin_objc::class!($name);
+        let ptr = ptr.cast_const().cast::<$crate::runtime::AnyClass>();
+        #[allow(unused_unsafe)]
+        let r: &'static $crate::runtime::AnyClass = unsafe { &*ptr };
+        r
+    }};
+}
+
 #[doc(hidden)]
 #[macro_export]
 #[cfg(all(

crates/objc2/src/__macros/mod.rs

@@ -52,6 +52,9 @@ pub use core::primitive::{bool, isize, str, u8};
 pub use core::{compile_error, concat, env, module_path, panic, stringify};
 pub use std::sync::Once;
 
+#[cfg(feature = "unstable-darwin-objc")]
+pub use core::os::darwin::objc as core_darwin_objc;
+
 pub use self::available::{is_available, AvailableVersion, OSVersion};
 pub use self::class::{disallow_in_static, CachedClass};
 pub use self::convert::{ConvertArgument, ConvertArguments, ConvertReturn, TupleExtender};

crates/objc2/src/__macros/sel.rs

@@ -49,13 +49,29 @@ use crate::runtime::Sel;
 /// - runtime, causing UB (unlikely)
 ///
 /// The `"unstable-static-sel-inlined"` feature is the even more extreme
-/// version - it yields the best performance and is closest to real
+/// version - it yield better performance and is closer to real
 /// Objective-C code, but probably won't work unless your code and its
 /// inlining is written in a very certain way.
 ///
 /// Enabling LTO greatly increases the chance that these features work.
 ///
+/// On Apple/Darwin targets, these limitations can be overcome with the
+/// `"unstable-darwin-objc"` feature which uses the nightly-only `darwin_objc`
+/// language feature. This experimental language feature implements the
+/// Objective-C static selector ABI directly in the Rust compiler and should
+/// work in more if not all cases. Using `"unstable-darwin-objc"` requires
+/// `darwin_objc` to be enabled in every crate that uses this macro, which can
+/// be achieved in `objc2` crates by enabling their own
+/// `"unstable-darwin-objc"` features and in your own crates by adding
+/// `#![feature(darwin_objc)]`.
+///
+/// See [rust-lang/rust#145496] for the tracking issue for the feature.
+///
+/// `"unstable-static-sel"` and `"unstable-static-sel-inlined"` take
+/// precedence over `"unstable-darwin-objc"`.
+///
 /// [rust-lang/rust#53929]: https://github.com/rust-lang/rust/issues/53929
+/// [rust-lang/rust#145496]: https://github.com/rust-lang/rust/issues/145496
 ///
 ///
 /// # Examples
@@ -177,9 +193,9 @@ macro_rules! __sel_helper {
     // Base-case
     {
         ($($parsed_sel:tt)*)
-    } => ({
+    } => {
         $crate::__sel_data!($($parsed_sel)*)
-    });
+    };
     // Single identifier
     {
         ()
@@ -219,20 +235,36 @@ macro_rules! __sel_data {
         $crate::__macros::concat!(
             $crate::__macros::stringify!($first),
             $(':', $($($crate::__macros::stringify!($rest),)? ':',)*)?
-            '\0',
         )
     };
 }
 
 #[doc(hidden)]
 #[macro_export]
-#[cfg(not(feature = "unstable-static-sel"))]
+#[cfg(not(any(feature = "unstable-darwin-objc", feature = "unstable-static-sel")))]
 macro_rules! __sel_inner {
     ($data:expr, $_hash:expr) => {{
         static CACHED_SEL: $crate::__macros::CachedSel = $crate::__macros::CachedSel::new();
         #[allow(unused_unsafe)]
         unsafe {
-            CACHED_SEL.get($data)
+            CACHED_SEL.get($crate::__macros::concat!($data, '\0'))
+        }
+    }};
+}
+
+#[doc(hidden)]
+#[macro_export]
+#[cfg(all(
+    feature = "unstable-darwin-objc",
+    not(feature = "unstable-static-sel")
+))]
+macro_rules! __sel_inner {
+    ($data:expr, $_hash:expr) => {{
+        let ptr = $crate::__macros::core_darwin_objc::selector!($data);
+        let ptr = ptr.cast_const().cast::<$crate::__macros::u8>();
+        #[allow(unused_unsafe)]
+        unsafe {
+            $crate::runtime::Sel::__internal_from_ptr(ptr)
         }
     }};
 }
@@ -245,7 +277,7 @@ macro_rules! __statics_sel {
         ($data:expr)
         ($hash:expr)
     } => {
-        const X: &[$crate::__macros::u8] = $data.as_bytes();
+        const X: &[$crate::__macros::u8] = $crate::__macros::concat!($data, '\0').as_bytes();
 
         /// Clang marks this with LLVM's `unnamed_addr`.
         /// See rust-lang/rust#18297
@@ -425,30 +457,30 @@ impl CachedSel {
 
 #[inline]
 pub fn alloc_sel() -> Sel {
-    __sel_inner!("alloc\0", "alloc")
+    __sel_inner!("alloc", "alloc")
 }
 
 #[inline]
 pub fn init_sel() -> Sel {
-    __sel_inner!("init\0", "init")
+    __sel_inner!("init", "init")
 }
 
 #[inline]
 pub fn new_sel() -> Sel {
-    __sel_inner!("new\0", "new")
+    __sel_inner!("new", "new")
 }
 
 #[inline]
 pub fn dealloc_sel() -> Sel {
-    __sel_inner!("dealloc\0", "dealloc")
+    __sel_inner!("dealloc", "dealloc")
 }
 
 /// An undocumented selector called by the Objective-C runtime when
 /// initializing instance variables.
 #[inline]
 #[allow(dead_code)] // May be useful in the future
 fn cxx_construct_sel() -> Sel {
-    __sel_inner!(".cxx_construct\0", ".cxx_construct")
+    __sel_inner!(".cxx_construct", ".cxx_construct")
 }
 
 /// Objective-C runtimes call `.cxx_destruct` as part of the final `dealloc`
@@ -485,7 +517,7 @@ fn cxx_construct_sel() -> Sel {
 #[inline]
 #[allow(dead_code)] // May be useful in the future
 fn cxx_destruct_sel() -> Sel {
-    __sel_inner!(".cxx_destruct\0", ".cxx_destruct")
+    __sel_inner!(".cxx_destruct", ".cxx_destruct")
 }
 
 #[cfg(test)]

crates/objc2/src/lib.rs

@@ -102,6 +102,7 @@
 //! [#203]: https://github.com/madsmtm/objc2/issues/203
 
 #![no_std]
+#![cfg_attr(feature = "unstable-darwin-objc", feature(darwin_objc))]
 #![cfg_attr(
     feature = "unstable-autoreleasesafe",
     feature(negative_impls, auto_traits)

examples/app/Cargo.toml

@@ -18,6 +18,9 @@ path = "default_xcode_app/main.rs"
 name = "hello_world_app"
 path = "hello_world_app.rs"
 
+[features]
+unstable-darwin-objc = []
+
 [dependencies]
 objc2 = "0.6.2"
 objc2-foundation = { version = "0.3.1", default-features = false, features = [

examples/app/default_xcode_app/main.rs

@@ -3,6 +3,8 @@
 //! Using a Storyboard outside of Xcode is quite involved, so instead, we set
 //! up the entire UI (menubar and window) ourselves.
 
+#![cfg_attr(feature = "unstable-darwin-objc", feature(darwin_objc))]
+
 use objc2::MainThreadMarker;
 use objc2_app_kit::NSApplication;
 

examples/app/delegate.rs

@@ -1,5 +1,6 @@
 //! Implementing `NSApplicationDelegate` for a custom class.
 #![deny(unsafe_op_in_unsafe_fn)]
+#![cfg_attr(feature = "unstable-darwin-objc", feature(darwin_objc))]
 use objc2::rc::Retained;
 use objc2::runtime::ProtocolObject;
 use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker, MainThreadOnly};

examples/app/hello_world_app.rs

@@ -1,4 +1,5 @@
 #![deny(unsafe_op_in_unsafe_fn)]
+#![cfg_attr(feature = "unstable-darwin-objc", feature(darwin_objc))]
 use std::cell::OnceCell;
 
 use objc2::rc::Retained;