TMP improve NSEnumerator

TMP

TMP2

TMP3

TMP

Fix

Complete somewhat

Add explicit lifetime bounds on iterators

To help catch possible soundness mistakes in the future.

Fixes

Author: madsmtm

crates/header-translator/src/data/Foundation.rs

@@ -12,6 +12,28 @@ data! {
         unsafe -removeAllObjects;
     }
 
+    // SAFETY: `NSEnumerator` and subclasses are safe as mutable because even
+    // though the items it contains are not mutable, the enumerator itself is
+    // (and it is important that the methods below are marked `&mut` as well).
+    //
+    // However, instances of this are only safe for others to create if
+    // they're ready to pass ownership to the enumerator, or if they somehow
+    // add a lifetime parameter (to prevent the original collection from
+    // being modified).
+    //
+    // So e.g. `Id<NSArray<T>> -> Id<NSEnumerator<T>>` is safe, as is
+    // `&Id<NSArray<T: IsCloneable>> -> Id<NSEnumerator<T>>`, and so is
+    // `&'a NSArray<T: IsCloneable> -> Id<NSEnumerator<T>> + 'a`.
+    class NSEnumerator: Mutable {
+        // SAFETY: This removes the object from the internal collection, so it
+        // may safely return `Id<T>`.
+        unsafe -nextObject;
+        // SAFETY: The objects are removed from the internal collection and as
+        // such are safe to give ownership over.
+        unsafe -allObjects;
+    }
+    class NSDirectoryEnumerator: Mutable {}
+
     class NSString: ImmutableWithMutableSubclass<Foundation::NSMutableString> {
         unsafe -init;
         unsafe -compare;

crates/header-translator/translation-config.toml

@@ -574,6 +574,10 @@ skipped = true
 [struct.NSDecimal]
 skipped = true
 
+# Uses `c_ulong` which means we need to specify the encoding manually.
+[struct.NSFastEnumerationState]
+skipped = true
+
 # Uses stuff from core Darwin libraries which we have not yet mapped
 [class.NSAppleEventDescriptor.methods]
 descriptorWithDescriptorType_bytes_length = { skipped = true }
@@ -1551,6 +1555,8 @@ definition-skipped = true
 definition-skipped = true
 [class.NSMutableOrderedSet]
 definition-skipped = true
+[class.NSEnumerator]
+definition-skipped = true
 
 # These protocol impls would return the wrong types
 [class.NSSimpleCString]

crates/icrate/src/Foundation/additions/array.rs

@@ -1,13 +1,14 @@
+//! Utilities for the `NSArray` and `NSMutableArray` classes.
 #![cfg(feature = "Foundation_NSArray")]
 use alloc::vec::Vec;
 use core::fmt;
 use core::mem;
 use core::ops::{Index, IndexMut, Range};
 use core::panic::{RefUnwindSafe, UnwindSafe};
 
-use objc2::msg_send;
 use objc2::mutability::{IsMutable, IsRetainable};
 
+use super::iter;
 use super::util;
 use crate::common::*;
 #[cfg(feature = "Foundation_NSMutableArray")]
@@ -220,15 +221,6 @@ extern_methods!(
 );
 
 impl<T: Message> NSArray<T> {
-    #[doc(alias = "objectEnumerator")]
-    #[cfg(feature = "Foundation_NSEnumerator")]
-    pub fn iter(&self) -> Foundation::NSEnumerator2<'_, T> {
-        unsafe {
-            let result: *mut Object = msg_send![self, objectEnumerator];
-            Foundation::NSEnumerator2::from_ptr(result)
-        }
-    }
-
     unsafe fn objects_in_range_unchecked(&self, range: Range<usize>) -> Vec<&T> {
         let range = Foundation::NSRange::from(range);
         let mut vec: Vec<NonNull<T>> = Vec::with_capacity(range.length);
@@ -340,33 +332,109 @@ impl<T: Message> NSMutableArray<T> {
     }
 }
 
-unsafe impl<T: Message> Foundation::NSFastEnumeration2 for NSArray<T> {
+impl<T: Message> NSArray<T> {
+    #[doc(alias = "objectEnumerator")]
+    #[inline]
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter(super::iter::Iter::new(self))
+    }
+
+    #[doc(alias = "objectEnumerator")]
+    #[inline]
+    pub fn iter_mut(&mut self) -> IterMut<'_, T>
+    where
+        T: IsMutable,
+    {
+        IterMut(super::iter::IterMut::new(self))
+    }
+
+    #[doc(alias = "objectEnumerator")]
+    #[inline]
+    pub fn iter_retained(&self) -> IterRetained<'_, T>
+    where
+        T: IsIdCloneable,
+    {
+        IterRetained(super::iter::IterRetained::new(self))
+    }
+}
+
+unsafe impl<T: Message> iter::FastEnumerationHelper for NSArray<T> {
     type Item = T;
+
+    #[inline]
+    fn maybe_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
 }
 
 #[cfg(feature = "Foundation_NSMutableArray")]
-unsafe impl<T: Message> Foundation::NSFastEnumeration2 for NSMutableArray<T> {
+unsafe impl<T: Message> iter::FastEnumerationHelper for NSMutableArray<T> {
     type Item = T;
+
+    #[inline]
+    fn maybe_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
 }
 
-impl<'a, T: Message> IntoIterator for &'a NSArray<T> {
-    type Item = &'a T;
-    type IntoIter = Foundation::NSFastEnumerator2<'a, NSArray<T>>;
+/// Immutable `NSArray` iterator.
+#[derive(Debug)]
+pub struct Iter<'a, T: Message>(iter::Iter<'a, NSArray<T>>);
 
-    fn into_iter(self) -> Self::IntoIter {
-        use Foundation::NSFastEnumeration2;
-        self.iter_fast()
-    }
+__impl_iter! {
+    impl<'a, T: Message> Iterator<Item = &'a T> for Iter<'a, T> { ... }
 }
 
-#[cfg(feature = "Foundation_NSMutableArray")]
-impl<'a, T: Message> IntoIterator for &'a NSMutableArray<T> {
-    type Item = &'a T;
-    type IntoIter = Foundation::NSFastEnumerator2<'a, NSMutableArray<T>>;
+/// Mutable `NSArray` iterator.
+#[derive(Debug)]
+pub struct IterMut<'a, T: Message>(iter::IterMut<'a, NSArray<T>>);
+
+__impl_iter! {
+    impl<'a, T: IsMutable> Iterator<Item = &'a mut T> for IterMut<'a, T> { ... }
+}
+
+/// Retained `NSArray` iterator.
+#[derive(Debug)]
+pub struct IterRetained<'a, T: Message>(iter::IterRetained<'a, NSArray<T>>);
+
+__impl_iter! {
+    impl<'a, T: IsIdCloneable> Iterator<Item = Id<T>> for IterRetained<'a, T> { ... }
+}
+
+/// Consuming `NSArray` iterator.
+#[derive(Debug)]
+pub struct IntoIter<T: Message>(iter::IntoIter<NSArray<T>>);
+
+__impl_iter! {
+    impl<'a, T: Message> Iterator<Item = Id<T>> for IntoIter<T> { ... }
+}
+
+__impl_into_iter! {
+    impl<T: Message> IntoIterator for &NSArray<T> {
+        type IntoIter = Iter<'_, T>;
+    }
+
+    #[cfg(feature = "Foundation_NSMutableArray")]
+    impl<T: Message> IntoIterator for &NSMutableArray<T> {
+        type IntoIter = Iter<'_, T>;
+    }
+
+    impl<T: IsMutable> IntoIterator for &mut NSArray<T> {
+        type IntoIter = IterMut<'_, T>;
+    }
+
+    #[cfg(feature = "Foundation_NSMutableArray")]
+    impl<T: IsMutable> IntoIterator for &mut NSMutableArray<T> {
+        type IntoIter = IterMut<'_, T>;
+    }
+
+    impl<T: IsIdCloneable> IntoIterator for Id<NSArray<T>> {
+        type IntoIter = IntoIter<T>;
+    }
 
-    fn into_iter(self) -> Self::IntoIter {
-        use Foundation::NSFastEnumeration2;
-        self.iter_fast()
+    #[cfg(feature = "Foundation_NSMutableArray")]
+    impl<T: Message> IntoIterator for Id<NSMutableArray<T>> {
+        type IntoIter = IntoIter<T>;
     }
 }
 
@@ -403,8 +471,7 @@ impl<T: IsMutable> IndexMut<usize> for NSMutableArray<T> {
 impl<T: fmt::Debug + Message> fmt::Debug for NSArray<T> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use Foundation::NSFastEnumeration2;
-        f.debug_list().entries(self.iter_fast()).finish()
+        f.debug_list().entries(self).finish()
     }
 }