Use common macro helpers

Author: madsmtm

objc2/src/__macro_helpers.rs

@@ -6,12 +6,17 @@ use crate::{Message, MessageArguments, MessageReceiver};
 pub use crate::cache::CachedClass;
 pub use crate::cache::CachedSel;
 
+pub use core::borrow::{Borrow, BorrowMut};
 pub use core::cell::UnsafeCell;
+pub use core::convert::{AsMut, AsRef};
+pub use core::ops::{Deref, DerefMut};
 pub use core::option::Option::{self, None, Some};
 pub use core::primitive::{bool, str, u8};
 pub use core::{compile_error, concat, panic, stringify};
 #[cfg(feature = "objc2-proc-macros")]
 pub use objc2_proc_macros::__hash_idents;
+// TODO: Use `core::cell::LazyCell`
+pub use std::sync::Once;
 
 // Common selectors.
 //

objc2/src/macros/ns_string.rs renamed to objc2/src/foundation/__ns_string.rs

@@ -354,7 +354,7 @@ macro_rules! __ns_string_inner {
         // The full UTF-16 contents along with the written length.
         const UTF16_FULL: (&[u16; $inp.len()], usize) = {
             let mut out = [0u16; $inp.len()];
-            let mut iter = $crate::__string_macro::EncodeUtf16Iter::new($inp);
+            let mut iter = $crate::foundation::__ns_string::EncodeUtf16Iter::new($inp);
             let mut written = 0;
 
             while let Some((state, chars)) = iter.next() {
@@ -395,17 +395,17 @@ macro_rules! __ns_string_inner {
         // The section is the same as what clang sets, see:
         // https://github.com/llvm/llvm-project/blob/release/13.x/clang/lib/CodeGen/CodeGenModule.cpp#L5243
         #[link_section = "__DATA,__cfstring"]
-        static CFSTRING: $crate::__string_macro::CFConstString = unsafe {
-            if $crate::__string_macro::is_ascii_no_nul($inp) {
+        static CFSTRING: $crate::foundation::__ns_string::CFConstString = unsafe {
+            if $crate::foundation::__ns_string::is_ascii_no_nul($inp) {
                 // This is technically an optimization (UTF-16 strings are
                 // always valid), but it's a fairly important one!
-                $crate::__string_macro::CFConstString::new_ascii(
-                    &$crate::__string_macro::__CFConstantStringClassReference,
+                $crate::foundation::__ns_string::CFConstString::new_ascii(
+                    &$crate::foundation::__ns_string::__CFConstantStringClassReference,
                     &ASCII,
                 )
             } else {
-                $crate::__string_macro::CFConstString::new_utf16(
-                    &$crate::__string_macro::__CFConstantStringClassReference,
+                $crate::foundation::__ns_string::CFConstString::new_utf16(
+                    &$crate::foundation::__ns_string::__CFConstantStringClassReference,
                     &UTF16,
                 )
             }
@@ -418,7 +418,7 @@ macro_rules! __ns_string_inner {
 #[macro_export]
 macro_rules! __ns_string_inner {
     ($inp:ident) => {{
-        use $crate::__string_macro::CachedNSString;
+        use $crate::foundation::__ns_string::CachedNSString;
         static CACHED_NSSTRING: CachedNSString = CachedNSString::new();
         CACHED_NSSTRING.get($inp)
     }};
@@ -508,7 +508,7 @@ mod tests {
             "\0",
             "\0\x01\x02\x03\x04\x05\x06\x07\x08\x09",
             // "\u{feff}", // TODO
-            include_str!("ns_string.rs"),
+            include_str!("__ns_string.rs"),
         }
     }
 

objc2/src/foundation/mod.rs

@@ -62,6 +62,8 @@ extern "C" {}
 #[link(name = "gnustep-base", kind = "dylib")]
 extern "C" {}
 
+#[doc(hidden)]
+pub mod __ns_string;
 mod array;
 mod attributed_string;
 mod comparison_result;

objc2/src/lib.rs

@@ -219,15 +219,6 @@ mod test_utils;
 #[cfg(feature = "malloc")]
 mod verify;
 
-// Hack to make foundation work for now
-#[doc(hidden)]
-pub extern crate core as __core;
-#[doc(hidden)]
-pub extern crate std as __std;
-#[doc(hidden)]
-#[cfg(feature = "foundation")]
-pub use self::macros::ns_string as __string_macro;
-
 // Hack to make doctests work
 #[cfg(all(feature = "apple", feature = "unstable-static-class"))]
 #[link(name = "Foundation", kind = "framework")]

objc2/src/macros.rs

@@ -1,8 +1,5 @@
 mod declare_class;
 mod extern_class;
-#[doc(hidden)]
-#[cfg(feature = "foundation")]
-pub mod ns_string;
 
 /// Gets a reference to a [`Class`] from the given name.
 ///

objc2/src/macros/declare_class.rs

@@ -511,8 +511,7 @@ macro_rules! declare_class {
             )]
             // TODO: Allow users to configure this?
             $v fn class() -> &'static $crate::runtime::Class {
-                // TODO: Use `core::cell::LazyCell`
-                use $crate::__std::sync::Once;
+                use $crate::__macro_helpers::Once;
 
                 use $crate::declare::ClassBuilder;
                 use $crate::runtime::{Class, Protocol};

objc2/src/macros/extern_class.rs

@@ -127,15 +127,15 @@ macro_rules! extern_class {
 macro_rules! __impl_as_ref_borrow {
     ($name:ident<$($t:ident $(: $b:ident)?),*>,) => {};
     ($name:ident<$($t:ident $(: $b:ident)?),*>, $item:ty, $($tail:ty,)*) => {
-        impl<$($t $(: $b)?),*> $crate::__core::convert::AsRef<$item> for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::AsRef<$item> for $name<$($t),*> {
             #[inline]
             fn as_ref(&self) -> &$item {
                 // Triggers Deref coercion depending on return type
                 &*self
             }
         }
 
-        impl<$($t $(: $b)?),*> $crate::__core::convert::AsMut<$item> for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::AsMut<$item> for $name<$($t),*> {
             #[inline]
             fn as_mut(&mut self) -> &mut $item {
                 // Triggers DerefMut coercion depending on return type
@@ -149,15 +149,15 @@ macro_rules! __impl_as_ref_borrow {
         // In particular, `Eq`, `Ord` and `Hash` all give the same results
         // after borrow.
 
-        impl<$($t $(: $b)?),*> $crate::__core::borrow::Borrow<$item> for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::Borrow<$item> for $name<$($t),*> {
             #[inline]
             fn borrow(&self) -> &$item {
                 // Triggers Deref coercion depending on return type
                 &*self
             }
         }
 
-        impl<$($t $(: $b)?),*> $crate::__core::borrow::BorrowMut<$item> for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::BorrowMut<$item> for $name<$($t),*> {
             #[inline]
             fn borrow_mut(&mut self) -> &mut $item {
                 // Triggers Deref coercion depending on return type
@@ -253,7 +253,7 @@ macro_rules! __inner_extern_class {
         // Note that you can easily have two different variables pointing to
         // the same object, `x: &T` and `y: &T::Target`, and this would be
         // perfectly safe!
-        impl<$($t $(: $b)?),*> $crate::__core::ops::Deref for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::Deref for $name<$($t),*> {
             type Target = $superclass;
 
             #[inline]
@@ -273,21 +273,21 @@ macro_rules! __inner_extern_class {
         // But `&mut NSMutableString` -> `&mut NSString` safe, since the
         // `NSCopying` implementation of `NSMutableString` is used, and that
         // is guaranteed to return a different object.
-        impl<$($t $(: $b)?),*> $crate::__core::ops::DerefMut for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::DerefMut for $name<$($t),*> {
             #[inline]
             fn deref_mut(&mut self) -> &mut Self::Target {
                 &mut self.__inner
             }
         }
 
-        impl<$($t $(: $b)?),*> $crate::__core::convert::AsRef<Self> for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::AsRef<Self> for $name<$($t),*> {
             #[inline]
             fn as_ref(&self) -> &Self {
                 self
             }
         }
 
-        impl<$($t $(: $b)?),*> $crate::__core::convert::AsMut<Self> for $name<$($t),*> {
+        impl<$($t $(: $b)?),*> $crate::__macro_helpers::AsMut<Self> for $name<$($t),*> {
             #[inline]
             fn as_mut(&mut self) -> &mut Self {
                 self

test-ui/ui/nsvalue_f32_not_eq.stderr

@@ -1,10 +1,10 @@
-error[E0277]: the trait bound `f32: std::cmp::Eq` is not satisfied
+error[E0277]: the trait bound `f32: Eq` is not satisfied
   --> ui/nsvalue_f32_not_eq.rs
    |
    |     needs_eq::<NSValue<f32>>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::cmp::Eq` is not implemented for `f32`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Eq` is not implemented for `f32`
    |
-   = help: the following other types implement trait `std::cmp::Eq`:
+   = help: the following other types implement trait `Eq`:
              i128
              i16
              i32
@@ -14,7 +14,7 @@ error[E0277]: the trait bound `f32: std::cmp::Eq` is not satisfied
              u128
              u16
            and 4 others
-   = note: required because of the requirements on the impl of `std::cmp::Eq` for `NSValue<f32>`
+   = note: required because of the requirements on the impl of `Eq` for `NSValue<f32>`
 note: required by a bound in `needs_eq`
   --> ui/nsvalue_f32_not_eq.rs
    |