Merge pull request #223 from madsmtm/cleanup-after-move

Cleanup after moving `objc2::foundation`

Author: madsmtm

README.md

@@ -12,9 +12,8 @@ appreciated!
 ## Crate overview
 
 The core crate is [`objc2`], which contains everything you need to interface
-with Objective-C. We use it in [`objc2-foundation`] to provide a safe
-abstraction over some core objects from the Foundation Framework, since these
-are used in almost all other Objective-C frameworks.
+with Objective-C. It also provides safe abstraction over (parts of) the
+Foundation Framework, since that is used in almost all Objective-C code.
 
 [`block2`] has a bit of a weird position in all of this: Apple's C language
 extension of blocks is _technically_ not limited to being used in Objective-C,
@@ -27,7 +26,6 @@ separate crate to help people cutting down on unneeded dependencies.
 runtime libraries.
 
 [`objc2`]: ./objc2
-[`objc2-foundation`]: ./objc2-foundation
 [`block2`]: ./block2
 [`objc2-encode`]: ./objc2-encode
 [`objc-sys`]: ./objc-sys
@@ -126,21 +124,27 @@ Work is in progress to make it dual-licensed under the Apache License
 
 ## Acknowledgements
 
-This repository is originally a fork of [`objc`] (hence the name `objc2`),
-with the following projects merged into it (see reasoning for the fork
-[here][origin-issue-101]):
+This repository is a merge of the following projects, see reasoning for the
+fork [here][origin-issue-101]:
+- [`objc`](https://github.com/SSheldon/rust-objc)
+  - Renamed to `objc2`.
 - [`objc-encode`](https://github.com/SSheldon/rust-objc-encode)
+  - Renamed to `objc2-encode`.
 - [`objc_exception`](https://github.com/SSheldon/rust-objc-exception)
+  - Moved to `objc2::exception`.
 - [`objc_id`](https://github.com/SSheldon/rust-objc-id)
+  - Moved to `objc2::rc`.
 - [`objc-foundation`](https://github.com/SSheldon/rust-objc-foundation)
+  - Moved to `objc2::foundation`.
 - [`block`](https://github.com/SSheldon/rust-block)
+  - Renamed to `block2`.
 
 These were created almost solely by [@SSheldon](https://github.com/SSheldon),
 so a huge thanks for their fantastic work on these crates!
 
-This project also draws heavy inspiration from [`fruity`] and [`objrs`].
+This project also draws heavy inspiration from [`fruity`], the [`core-foundation-rs` project] and [`objrs`].
 
-[`objc`]: https://github.com/SSheldon/rust-objc
 [origin-issue-101]: https://github.com/SSheldon/rust-objc/issues/101
 [`fruity`]: https://github.com/nvzqz/fruity
+[`core-foundation-rs` project]: https://github.com/servo/core-foundation-rs
 [`objrs`]: https://gitlab.com/objrs/objrs

objc-sys/src/types.rs

@@ -156,7 +156,7 @@ pub type NSInteger = isize;
 /// use objc_sys::NSUInteger;
 /// // Or:
 /// // use objc2::ffi::NSUInteger;
-/// // use objc2_foundation::NSUInteger;
+/// // use objc2::foundation::NSUInteger;
 /// extern "C" {
 ///     fn some_external_function() -> NSUInteger;
 /// }

objc2/benches/autorelease.rs

@@ -5,14 +5,6 @@ use objc2::rc::{autoreleasepool, Id, Shared};
 use objc2::runtime::{Class, Object, Sel};
 use objc2::{class, msg_send, sel};
 
-#[cfg(feature = "apple")]
-#[link(name = "Foundation", kind = "framework")]
-extern "C" {}
-
-#[cfg(feature = "gnustep-1-7")]
-#[link(name = "gnustep-base", kind = "dylib")]
-extern "C" {}
-
 const BYTES: &[u8] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
 fn empty() {

objc2/examples/introspection.rs

@@ -1,16 +1,13 @@
+use objc2::msg_send;
 use objc2::rc::{Id, Owned};
-use objc2::runtime::{Class, Object};
-use objc2::{class, msg_send, msg_send_id};
+use objc2::runtime::Class;
+use objc2::{foundation::NSObject, msg_send_id};
 #[cfg(feature = "malloc")]
 use objc2::{sel, Encode};
 
-#[cfg(feature = "apple")]
-#[link(name = "Foundation", kind = "framework")]
-extern "C" {}
-
 fn main() {
     // Get a class
-    let cls = class!(NSObject);
+    let cls = NSObject::class();
     println!("NSObject size: {}", cls.instance_size());
 
     #[cfg(feature = "malloc")]
@@ -23,10 +20,12 @@ fn main() {
     }
 
     // Allocate an instance
-    let obj: Id<Object, Owned> = unsafe {
+    let obj: Id<NSObject, Owned> = unsafe {
         let obj = msg_send_id![cls, alloc];
         msg_send_id![obj, init].unwrap()
     };
+    // In this case `let obj = NSObject::new()` would have been the same
+
     println!("NSObject address: {:p}", obj);
 
     // Access an ivar of the object

objc2/examples/nspasteboard.rs

@@ -96,7 +96,7 @@ impl NSPasteboard {
     /// <https://developer.apple.com/documentation/appkit/nspasteboard/1524454-readobjectsforclasses?language=objc>
     pub fn text_impl_2(&self) -> Id<NSString, Shared> {
         // The NSPasteboard API is a bit weird, it requires you to pass
-        // classes as objects, which `objc2_foundation::NSArray` was not
+        // classes as objects, which `objc2::foundation::NSArray` was not
         // really made for - so we convert the class to an `Object` type
         // instead. Also, we wrap it in `ManuallyDrop` because I'm not sure
         // how classes handle `release` calls?

objc2/examples/talk_to_me.rs

@@ -11,42 +11,21 @@ fn main() {
 
 #[cfg(talk_to_me_example)]
 fn main() {
-    use objc2::ffi::NSUInteger;
-    use objc2::rc::{Id, Owned, Shared};
+    use objc2::rc::{Id, Owned};
     use objc2::runtime::Object;
-    use objc2::{class, msg_send, msg_send_bool, msg_send_id};
-    use std::ffi::c_void;
+    use objc2::{class, msg_send, msg_send_bool, msg_send_id, ns_string};
 
-    #[cfg(feature = "apple")]
     #[link(name = "AVFoundation", kind = "framework")]
     extern "C" {}
-    #[cfg(feature = "apple")]
-    #[link(name = "Foundation", kind = "framework")]
-    extern "C" {}
-
-    const UTF8_ENCODING: NSUInteger = 4;
 
-    let text = "Hello from Rust!";
-
-    // Note: objc2-foundation has functionality to do this safely!
-    let string = unsafe { msg_send_id![class!(NSString), alloc] };
-    let text_ptr: *const c_void = text.as_ptr().cast();
-    let string: Id<Object, Shared> = unsafe {
-        msg_send_id![
-            string,
-            initWithBytes: text_ptr,
-            length: text.len(),
-            encoding: UTF8_ENCODING,
-        ]
-    }
-    .unwrap();
+    let string = ns_string!("Hello from Rust!");
 
     let synthesizer: Id<Object, Owned> =
         unsafe { msg_send_id![class!(AVSpeechSynthesizer), new] }.unwrap();
 
     let utterance = unsafe { msg_send_id![class!(AVSpeechUtterance), alloc] };
     let utterance: Id<Object, Owned> =
-        unsafe { msg_send_id![utterance, initWithString: &*string] }.unwrap();
+        unsafe { msg_send_id![utterance, initWithString: string] }.unwrap();
 
     // let _: () = unsafe { msg_send![&utterance, setVolume: 90.0f32 };
     // let _: () = unsafe { msg_send![&utterance, setRate: 0.50f32 };

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/exception.rs

@@ -44,7 +44,7 @@ use crate::runtime::Object;
 use crate::Message;
 use crate::{msg_send, msg_send_bool, msg_send_id, sel};
 
-/// Unfortunate reimplementation of `objc2_foundation::NSString`.
+/// Unfortunate reimplementation of `objc2::foundation::NSString`.
 ///
 /// I guess this is the price of wanting to do things "right"...
 unsafe fn to_string_hack(obj: Id<Object, Shared>) -> String {

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

@@ -14,10 +14,9 @@ use core::mem::ManuallyDrop;
 use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 
-use objc2::rc::Id;
-use objc2::runtime::Class;
-
 use crate::foundation::NSString;
+use crate::rc::Id;
+use crate::runtime::Class;
 
 // This is defined in CoreFoundation, but we don't emit a link attribute
 // here because it is already linked via Foundation.
@@ -237,7 +236,7 @@ impl CachedNSString {
     }
 }
 
-/// Creates an [`NSString`][`crate::NSString`] from a static string.
+/// Creates an [`NSString`][`crate::foundation::NSString`] from a static string.
 ///
 /// Currently only supported on Apple targets.
 ///
@@ -248,7 +247,8 @@ impl CachedNSString {
 /// the argument, and produces a `&'static NSString`:
 ///
 /// ```
-/// use objc2_foundation::{ns_string, NSString};
+/// use objc2::ns_string;
+/// use objc2::foundation::NSString;
 /// # #[cfg(feature = "gnustep-1-7")]
 /// # unsafe { objc2::__gnustep_hack::get_class_to_force_linkage() };
 /// let hello: &'static NSString = ns_string!("hello");
@@ -267,7 +267,7 @@ impl CachedNSString {
 /// string to the most efficient encoding, you don't have to do anything!
 ///
 /// ```
-/// # use objc2_foundation::ns_string;
+/// # use objc2::ns_string;
 /// # #[cfg(feature = "gnustep-1-7")]
 /// # unsafe { objc2::__gnustep_hack::get_class_to_force_linkage() };
 /// let hello_ru = ns_string!("Привет");
@@ -285,7 +285,7 @@ impl CachedNSString {
 /// expect:
 ///
 /// ```
-/// # use objc2_foundation::ns_string;
+/// # use objc2::ns_string;
 /// # #[cfg(feature = "gnustep-1-7")]
 /// # unsafe { objc2::__gnustep_hack::get_class_to_force_linkage() };
 /// let example = ns_string!("example\0");
@@ -305,7 +305,7 @@ impl CachedNSString {
 /// Because of that, this should be preferred over [`NSString::from_str`]
 /// where possible.
 ///
-/// [`NSString::from_str`]: crate::NSString::from_str
+/// [`NSString::from_str`]: crate::foundation::NSString::from_str
 #[macro_export]
 macro_rules! ns_string {
     ($s:expr) => {{
@@ -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/array.rs

@@ -4,16 +4,14 @@ use core::marker::PhantomData;
 use core::ops::{Index, IndexMut, Range};
 use core::panic::{RefUnwindSafe, UnwindSafe};
 
-use objc2::rc::{DefaultId, Id, Owned, Ownership, Shared, SliceId};
-use objc2::runtime::{Class, Object};
-use objc2::Message;
-use objc2::{msg_send, msg_send_id};
-
 use super::{
     NSCopying, NSEnumerator, NSFastEnumeration, NSFastEnumerator, NSMutableArray, NSMutableCopying,
     NSObject, NSRange,
 };
-use crate::__inner_extern_class;
+use crate::rc::{DefaultId, Id, Owned, Ownership, Shared, SliceId};
+use crate::runtime::{Class, Object};
+use crate::Message;
+use crate::{__inner_extern_class, msg_send, msg_send_id};
 
 __inner_extern_class! {
     /// TODO
@@ -244,10 +242,9 @@ mod tests {
     use alloc::format;
     use alloc::vec::Vec;
 
-    use objc2::rc::autoreleasepool;
-
     use super::*;
     use crate::foundation::{NSString, NSValue};
+    use crate::rc::autoreleasepool;
 
     fn sample_array(len: usize) -> Id<NSArray<NSObject, Owned>, Owned> {
         let mut vec = Vec::with_capacity(len);