Merge objc2_id into objc2

Id is such a vital requirement for applications that there's no need to make it a "second class citizen". If we really feel it's too much of an experiment, we can always feature-flag it later.

Also, there's might be traits I'd like to implement for e.g. Option<Id> that is not possible if it lives in it's own crate!

Author: madsmtm

Cargo.toml

@@ -6,7 +6,6 @@ members = [
     "objc2_exception",
     "objc2_foundation",
     "objc2_foundation_derive",
-    "objc2_id",
     "objc2_sys",
     "objc2_test_utils",
 ]

objc2/src/macros.rs

@@ -66,13 +66,15 @@ macro_rules! sel {
 Sends a message to an object.
 
 The first argument can be any type that dereferences to a type that implements
-[`Message`], like a reference, a pointer, or an `objc2_id::Id` to an object.
+[`Message`], like a reference, a pointer, or an [`rc::Id`] to an
+object.
 
 The syntax is similar to the message syntax in Objective-C.
 
 Variadic arguments are not currently supported.
 
 [`Message`]: crate::Message
+[`rc::Id`]: crate::rc::Id
 
 # Panics
 

objc2_id/src/id.rs renamed to objc2/src/rc/id.rs

@@ -10,8 +10,8 @@ use core::ops::{Deref, DerefMut};
 use core::ptr;
 use core::ptr::NonNull;
 
-use objc2::rc::AutoreleasePool;
-use objc2::Message;
+use super::AutoreleasePool;
+use crate::Message;
 
 /// A type used to mark that a struct owns the object(s) it contains,
 /// so it has the sole references to them.
@@ -84,9 +84,33 @@ impl Ownership for Shared {}
 /// # Examples
 ///
 /// ```no_run
+/// use objc2::msg_send;
+/// use objc2::runtime::{Class, Object};
+/// use objc2::rc::{Id, WeakId, Shared};
+///
+/// let cls = Class::get("NSObject").unwrap();
+/// let obj: Id<Object> = unsafe {
+///     Id::new(msg_send![cls, new])
+/// };
+/// // obj will be released when it goes out of scope
+///
+/// // share the object so we can clone it
+/// let obj: Id<_, Shared> = obj.into();
+/// let another_ref = obj.clone();
+/// // dropping our other reference will decrement the retain count
+/// drop(another_ref);
+///
+/// let weak = WeakId::new(&obj);
+/// assert!(weak.load().is_some());
+/// // After the object is deallocated, our weak pointer returns none
+/// drop(obj);
+/// assert!(weak.load().is_none());
+/// ```
+///
+/// ```no_run
 /// # use objc2::{class, msg_send};
 /// # use objc2::runtime::Object;
-/// # use objc2_id::{Id, Owned, Shared};
+/// # use objc2::rc::{Id, Owned, Shared};
 /// # type T = Object;
 /// let mut owned: Id<T, Owned>;
 /// # owned = unsafe { Id::new(msg_send![class!(NSObject), new]) };
@@ -145,7 +169,7 @@ impl<T: Message, O: Ownership> Id<T, O> {
     /// ```no_run
     /// # use objc2::{class, msg_send};
     /// # use objc2::runtime::{Class, Object};
-    /// # use objc2_id::{Id, Owned};
+    /// # use objc2::rc::{Id, Owned};
     /// let cls: &Class;
     /// # let cls = class!(NSObject);
     /// let obj: &mut Object = unsafe { msg_send![cls, alloc] };
@@ -157,7 +181,7 @@ impl<T: Message, O: Ownership> Id<T, O> {
     /// ```no_run
     /// # use objc2::{class, msg_send};
     /// # use objc2::runtime::Object;
-    /// # use objc2_id::{Id, Shared};
+    /// # use objc2::rc::{Id, Shared};
     /// # type NSString = Object;
     /// let cls = class!(NSString);
     /// // NSString is immutable, so don't create an owned reference to it
@@ -627,14 +651,8 @@ mod tests {
     use core::ptr::NonNull;
 
     use super::{Id, Owned, ShareId, Shared, WeakId};
-    use objc2::runtime::Object;
-    use objc2::{class, msg_send};
-
-    #[cfg(not(target_vendor = "apple"))]
-    #[test]
-    fn ensure_linkage() {
-        unsafe { crate::get_class_to_force_linkage() };
-    }
+    use crate::runtime::Object;
+    use crate::{class, msg_send};
 
     fn retain_count(obj: &Object) -> usize {
         unsafe { msg_send![obj, retainCount] }

objc2/src/rc/mod.rs

@@ -1,58 +1,70 @@
-/*!
-Utilities for reference counting Objective-C objects.
-
-The utilities of the `rc` module provide ARC-like semantics for working with
-Objective-C's reference counted objects in Rust.
-A `StrongPtr` retains an object and releases the object when dropped.
-A `WeakPtr` will not retain the object, but can be upgraded to a `StrongPtr`
-and safely fails if the object has been deallocated.
-
-These utilities are not intended to provide a fully safe interface, but can be
-useful when writing higher-level Rust wrappers for Objective-C code.
-
-See [the clang documentation][clang-arc] and [the Apple article on memory
-management][mem-mgmt] (similar document exists [for Core Foundation][mem-cf])
-for more information on automatic and manual reference counting.
-
-It can also be useful to [enable Malloc Debugging][mem-debug] if you're trying
-to figure out if/where your application has memory errors and leaks.
-
-
-[clang-arc]: https://clang.llvm.org/docs/AutomaticReferenceCounting.html
-[mem-mgmt]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/MemoryMgmt.html
-[mem-cf]: https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/CFMemoryMgmt.html
-[mem-debug]: https://developer.apple.com/library/archive/documentation/Performance/Conceptual/ManagingMemory/Articles/MallocDebug.html
-
-# Example
-
-``` no_run
-# use objc2::{class, msg_send};
-# use objc2::rc::{autoreleasepool, StrongPtr};
-// StrongPtr will release the object when dropped
-let obj = unsafe {
-    StrongPtr::new(msg_send![class!(NSObject), new])
-};
-
-// Cloning retains the object an additional time
-let cloned = obj.clone();
-autoreleasepool(|_| {
-    // Autorelease consumes the StrongPtr, but won't
-    // actually release until the end of an autoreleasepool
-    cloned.autorelease();
-});
-
-// Weak references won't retain the object
-let weak = obj.weak();
-drop(obj);
-assert!(weak.load().is_null());
-```
-*/
+//! Utilities for reference counting Objective-C objects.
+//!
+//! The utilities of the `rc` module provide ARC-like semantics for working
+//! with Objective-C's reference counted objects in Rust.
+//!
+//! A `StrongPtr` retains an object and releases the object when dropped.
+//! A `WeakPtr` will not retain the object, but can be upgraded to a `StrongPtr`
+//! and safely fails if the object has been deallocated.
+//!
+//! These utilities are not intended to provide a fully safe interface, but can be
+//! useful when writing higher-level Rust wrappers for Objective-C code.
+//!
+//! A smart pointer version of this is provided with the `Id` struct.
+//! To ensure that Objective-C objects are retained and released
+//! at the proper times.
+//!
+//! To enforce aliasing rules, an `Id` can be either owned or shared; if it is
+//! owned, meaning the `Id` is the only reference to the object, it can be
+//! mutably dereferenced. An owned `Id` can be downgraded to a shared `Id`
+//! which can be cloned to allow multiple references.
+//!
+//! Weak references may be created using the [`WeakId`] struct.
+//!
+//! See [the clang documentation][clang-arc] and [the Apple article on memory
+//! management][mem-mgmt] (similar document exists [for Core Foundation][mem-cf])
+//! for more information on automatic and manual reference counting.
+//!
+//! It can also be useful to [enable Malloc Debugging][mem-debug] if you're trying
+//! to figure out if/where your application has memory errors and leaks.
+//!
+//!
+//! [clang-arc]: https://clang.llvm.org/docs/AutomaticReferenceCounting.html
+//! [mem-mgmt]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/MemoryMgmt.html
+//! [mem-cf]: https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/CFMemoryMgmt.html
+//! [mem-debug]: https://developer.apple.com/library/archive/documentation/Performance/Conceptual/ManagingMemory/Articles/MallocDebug.html
+//!
+//! # Example
+//!
+//! ``` no_run
+//! # use objc2::{class, msg_send};
+//! # use objc2::rc::{autoreleasepool, StrongPtr};
+//! // StrongPtr will release the object when dropped
+//! let obj = unsafe {
+//!     StrongPtr::new(msg_send![class!(NSObject), new])
+//! };
+//!
+//! // Cloning retains the object an additional time
+//! let cloned = obj.clone();
+//! autoreleasepool(|_| {
+//!     // Autorelease consumes the StrongPtr, but won't
+//!     // actually release until the end of an autoreleasepool
+//!     cloned.autorelease();
+//! });
+//!
+//! // Weak references won't retain the object
+//! let weak = obj.weak();
+//! drop(obj);
+//! assert!(weak.load().is_null());
+//! ```
 
 mod autorelease;
+mod id;
 mod strong;
 mod weak;
 
 pub use self::autorelease::{autoreleasepool, AutoreleasePool, AutoreleaseSafe};
+pub use self::id::{Id, Owned, Ownership, ShareId, Shared, WeakId};
 pub use self::strong::StrongPtr;
 pub use self::weak::WeakPtr;
 

objc2_foundation/Cargo.toml

@@ -24,4 +24,3 @@ block = ["objc2_block"]
 [dependencies]
 objc2_block = { path = "../objc2_block", optional = true }
 objc2 = { path = "../objc2" }
-objc2_id = { path = "../objc2_id" }

objc2_foundation/src/array.rs

@@ -5,10 +5,10 @@ use core::marker::PhantomData;
 use core::ops::{Index, Range};
 use core::ptr::NonNull;
 
+use objc2::rc::{Id, Owned, Ownership, ShareId, Shared};
 use objc2::runtime::{Class, Object};
 use objc2::{class, msg_send};
 use objc2::{Encode, Encoding};
-use objc2_id::{Id, Owned, Ownership, ShareId, Shared};
 
 use super::{INSCopying, INSFastEnumeration, INSMutableCopying, INSObject, NSEnumerator};
 
@@ -415,7 +415,7 @@ mod tests {
 
     use super::{INSArray, INSMutableArray, NSArray, NSMutableArray};
     use crate::{INSObject, INSString, NSObject, NSString};
-    use objc2_id::Id;
+    use objc2::rc::Id;
 
     fn sample_array(len: usize) -> Id<NSArray<NSObject>> {
         let mut vec = Vec::with_capacity(len);

objc2_foundation/src/data.rs

@@ -6,9 +6,9 @@ use core::{ffi::c_void, ptr::NonNull};
 
 use super::{INSCopying, INSMutableCopying, INSObject, NSRange};
 use objc2::msg_send;
+use objc2::rc::Id;
 #[cfg(feature = "block")]
 use objc2_block::{Block, ConcreteBlock};
-use objc2_id::Id;
 
 pub trait INSData: INSObject {
     fn len(&self) -> usize {

objc2_foundation/src/dictionary.rs

@@ -4,9 +4,9 @@ use core::marker::PhantomData;
 use core::ops::Index;
 use core::ptr::{self, NonNull};
 
+use objc2::rc::{Id, Owned, Ownership, ShareId};
 use objc2::runtime::Class;
 use objc2::{class, msg_send};
-use objc2_id::{Id, Owned, Ownership, ShareId};
 
 use super::{INSCopying, INSFastEnumeration, INSObject, NSArray, NSEnumerator, NSSharedArray};
 
@@ -166,7 +166,7 @@ where
 #[cfg(test)]
 mod tests {
     use alloc::vec;
-    use objc2_id::Id;
+    use objc2::rc::Id;
 
     use super::{INSDictionary, NSDictionary};
     use crate::{INSArray, INSObject, INSString, NSObject, NSString};

objc2_foundation/src/enumerator.rs

@@ -5,9 +5,9 @@ use core::ptr::NonNull;
 use core::slice;
 use std::os::raw::c_ulong;
 
+use objc2::rc::Id;
 use objc2::runtime::Object;
 use objc2::{msg_send, Encode, Encoding, RefEncode};
-use objc2_id::Id;
 
 use super::INSObject;
 

objc2_foundation/src/object.rs

@@ -2,9 +2,9 @@ use core::any::Any;
 use core::ptr::NonNull;
 
 use objc2::msg_send;
+use objc2::rc::{Id, ShareId};
 use objc2::runtime::{Class, BOOL, NO};
 use objc2::Message;
-use objc2_id::{Id, ShareId};
 
 use super::NSString;