diff --git a/crates/test-ui/ui/nsarray_not_message.stderr b/crates/test-ui/ui/nsarray_not_message.stderr
index 7b499e2e4..c50891702 100644
--- a/crates/test-ui/ui/nsarray_not_message.stderr
+++ b/crates/test-ui/ui/nsarray_not_message.stderr
@@ -46,11 +46,11 @@ error[E0277]: the trait bound `Retained<NSObject>: Message` is not satisfied
             NSEnumerator<ObjectType>
             NSError
           and $N others
-note: required by a bound in `objc2_foundation::array::<impl NSArray<T>>::from_slice`
+note: required by a bound in `objc2_foundation::array::<impl NSArray<ObjectType>>::from_slice`
  --> $WORKSPACE/framework-crates/objc2-foundation/src/array.rs
   |
-  | impl<T: Message> NSArray<T> {
-  |         ^^^^^^^ required by this bound in `objc2_foundation::array::<impl NSArray<T>>::from_slice`
+  | impl<ObjectType: Message> NSArray<ObjectType> {
+  |                  ^^^^^^^ required by this bound in `objc2_foundation::array::<impl NSArray<ObjectType>>::from_slice`
 ...
-  |     pub fn from_slice(slice: &[&T]) -> Retained<Self> {
+  |     pub fn from_slice(slice: &[&ObjectType]) -> Retained<Self> {
   |            ---------- required by a bound in this associated function
diff --git a/framework-crates/objc2-foundation/src/array.rs b/framework-crates/objc2-foundation/src/array.rs
index 5d5f9e22f..ab8adbee5 100644
--- a/framework-crates/objc2-foundation/src/array.rs
+++ b/framework-crates/objc2-foundation/src/array.rs
@@ -13,7 +13,7 @@ use crate::iter;
 use crate::{util, NSArray, NSMutableArray};
 
 /// Convenience creation methods.
-impl<T: Message> NSArray<T> {
+impl<ObjectType: Message> NSArray<ObjectType> {
     /// Create a new array from a slice of objects.
     ///
     /// This is a safe interface to `initWithObjects:count:`.
@@ -30,12 +30,12 @@ impl<T: Message> NSArray<T> {
     /// ]);
     /// ```
     #[doc(alias = "initWithObjects:count:")]
-    pub fn from_slice(slice: &[&T]) -> Retained<Self> {
+    pub fn from_slice(slice: &[&ObjectType]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::ref_ptr_cast_const(slice.as_ptr());
         // SAFETY:
-        // - All `T: Message` use interior mutability, and the array extends
-        //   the lifetime of them internally by retaining them.
+        // - All `ObjectType: Message` use interior mutability, and the array
+        //   extends the lifetime of them internally by retaining them.
         // - The pointer and length are valid until the method has finished
         //   executing, at which point the array will have created its own
         //   internal storage for holding the pointers.
@@ -58,7 +58,7 @@ impl<T: Message> NSArray<T> {
     /// ]);
     /// ```
     #[doc(alias = "initWithObjects:count:")]
-    pub fn from_retained_slice(slice: &[Retained<T>]) -> Retained<Self> {
+    pub fn from_retained_slice(slice: &[Retained<ObjectType>]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::retained_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `from_slice`, this is just a faster version to
@@ -71,9 +71,9 @@ impl<T: Message> NSArray<T> {
 }
 
 /// Convenience creation methods.
-impl<T: Message> NSMutableArray<T> {
+impl<ObjectType: Message> NSMutableArray<ObjectType> {
     #[doc(alias = "initWithObjects:count:")]
-    pub fn from_slice(slice: &[&T]) -> Retained<Self> {
+    pub fn from_slice(slice: &[&ObjectType]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::ref_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `NSArray::from_slice`.
@@ -81,7 +81,7 @@ impl<T: Message> NSMutableArray<T> {
     }
 
     #[doc(alias = "initWithObjects:count:")]
-    pub fn from_retained_slice(slice: &[Retained<T>]) -> Retained<Self> {
+    pub fn from_retained_slice(slice: &[Retained<ObjectType>]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::retained_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `NSArray::from_retained_slice`
@@ -100,7 +100,7 @@ impl<T: Message> NSMutableArray<T> {
 /// doing so - otherwise, we might end up accessing a deallocated object.
 ///
 /// [collections-own]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmPractical.html#//apple_ref/doc/uid/TP40004447-SW12
-impl<T: Message> NSArray<T> {
+impl<ObjectType: Message> NSArray<ObjectType> {
     /// Get a direct reference to one of the array's objects.
     ///
     /// Throws an error if the object was not found.
@@ -113,7 +113,7 @@ impl<T: Message> NSArray<T> {
     /// The array must not be mutated while the reference is live.
     #[doc(alias = "objectAtIndex:")]
     #[inline]
-    pub unsafe fn objectAtIndex_unchecked(&self, index: usize) -> &T {
+    pub unsafe fn objectAtIndex_unchecked(&self, index: usize) -> &ObjectType {
         // SAFETY: Upheld by caller.
         unsafe { msg_send![self, objectAtIndex: index] }
     }
@@ -128,7 +128,7 @@ impl<T: Message> NSArray<T> {
     /// The array must not be mutated while the reference is live.
     #[doc(alias = "firstObject")]
     #[inline]
-    pub unsafe fn firstObject_unchecked(&self) -> Option<&T> {
+    pub unsafe fn firstObject_unchecked(&self) -> Option<&ObjectType> {
         // SAFETY: Upheld by caller.
         unsafe { msg_send![self, firstObject] }
     }
@@ -143,7 +143,7 @@ impl<T: Message> NSArray<T> {
     /// The array must not be mutated while the reference is live.
     #[doc(alias = "lastObject")]
     #[inline]
-    pub unsafe fn lastObject_unchecked(&self) -> Option<&T> {
+    pub unsafe fn lastObject_unchecked(&self) -> Option<&ObjectType> {
         // SAFETY: Upheld by caller.
         unsafe { msg_send![self, lastObject] }
     }
@@ -157,10 +157,10 @@ impl<T: Message> NSArray<T> {
     ///
     /// The array must not be mutated while the returned references are alive.
     #[doc(alias = "getObjects:")]
-    pub unsafe fn to_vec_unchecked(&self) -> Vec<&T> {
+    pub unsafe fn to_vec_unchecked(&self) -> Vec<&ObjectType> {
         let len = self.count();
-        let mut vec: Vec<NonNull<T>> = Vec::with_capacity(len);
-        let ptr: NonNull<NonNull<T>> = NonNull::new(vec.as_mut_ptr()).unwrap();
+        let mut vec: Vec<NonNull<ObjectType>> = Vec::with_capacity(len);
+        let ptr: NonNull<NonNull<ObjectType>> = NonNull::new(vec.as_mut_ptr()).unwrap();
 
         // SAFETY: The buffer is at least the size of the array, as guaranteed
         // by `Vec::with_capacity`.
@@ -176,10 +176,10 @@ impl<T: Message> NSArray<T> {
         // uninitialized elements.
         unsafe { vec.set_len(len) };
 
-        // SAFETY: `NonNull<T>` has the same layout as `&T`, and the lifetime
-        // is bound to the array, and caller upholds that the array isn't
-        // mutated.
-        unsafe { mem::transmute::<Vec<NonNull<T>>, Vec<&T>>(vec) }
+        // SAFETY: `NonNull<ObjectType>` has the same layout as `&ObjectType`,
+        // and the lifetime is bound to the array, and caller upholds that the
+        // array isn't mutated.
+        unsafe { mem::transmute::<Vec<NonNull<ObjectType>>, Vec<&ObjectType>>(vec) }
     }
 
     /// Iterate over the array without retaining the elements.
@@ -194,13 +194,13 @@ impl<T: Message> NSArray<T> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "objectEnumerator")]
     #[inline]
-    pub unsafe fn iter_unchecked(&self) -> IterUnchecked<'_, T> {
+    pub unsafe fn iter_unchecked(&self) -> IterUnchecked<'_, ObjectType> {
         IterUnchecked(iter::IterUnchecked::new(self))
     }
 }
 
 /// Various accessor methods.
-impl<T: Message> NSArray<T> {
+impl<ObjectType: Message> NSArray<ObjectType> {
     /// The amount of elements in the array.
     #[doc(alias = "count")]
     #[inline]
@@ -216,7 +216,7 @@ impl<T: Message> NSArray<T> {
 
     /// Convert the array to a `Vec` of the array's objects.
     #[doc(alias = "getObjects:")]
-    pub fn to_vec(&self) -> Vec<Retained<T>> {
+    pub fn to_vec(&self) -> Vec<Retained<ObjectType>> {
         // SAFETY: We retain the elements below, so we know that the array
         // isn't mutated while the references are alive.
         //
@@ -225,14 +225,14 @@ impl<T: Message> NSArray<T> {
         // to rule this out though, as that's basically never going to happen,
         // and will make a lot of other things unsound too.
         let vec = unsafe { self.to_vec_unchecked() };
-        vec.into_iter().map(T::retain).collect()
+        vec.into_iter().map(ObjectType::retain).collect()
     }
 
     /// Iterate over the array's elements.
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "objectEnumerator")]
     #[inline]
-    pub fn iter(&self) -> Iter<'_, T> {
+    pub fn iter(&self) -> Iter<'_, ObjectType> {
         Iter(iter::Iter::new(self))
     }
 
@@ -243,7 +243,7 @@ impl<T: Message> NSArray<T> {
     /// Panics if the range was out of bounds.
     #[doc(alias = "getObjects:range:")]
     #[cfg(feature = "NSRange")]
-    pub fn objects_in_range(&self, range: core::ops::Range<usize>) -> Vec<Retained<T>> {
+    pub fn objects_in_range(&self, range: core::ops::Range<usize>) -> Vec<Retained<ObjectType>> {
         let count = self.count();
 
         // TODO: Replace this check with catching the thrown NSRangeException
@@ -255,27 +255,27 @@ impl<T: Message> NSArray<T> {
         }
 
         let range = crate::NSRange::from(range);
-        let mut vec: Vec<NonNull<T>> = Vec::with_capacity(range.length);
-        let ptr: NonNull<NonNull<T>> = NonNull::new(vec.as_mut_ptr()).unwrap();
+        let mut vec: Vec<NonNull<ObjectType>> = Vec::with_capacity(range.length);
+        let ptr: NonNull<NonNull<ObjectType>> = NonNull::new(vec.as_mut_ptr()).unwrap();
 
         // SAFETY: Mostly the same as in `to_vec_unchecked`.
         unsafe { self.getObjects_range(ptr, range) };
         unsafe { vec.set_len(range.length) };
-        let vec = unsafe { mem::transmute::<Vec<NonNull<T>>, Vec<&T>>(vec) };
+        let vec = unsafe { mem::transmute::<Vec<NonNull<ObjectType>>, Vec<&ObjectType>>(vec) };
 
-        vec.into_iter().map(T::retain).collect()
+        vec.into_iter().map(ObjectType::retain).collect()
     }
 }
 
 /// Convenience mutation methods.
-impl<T: Message> NSMutableArray<T> {
+impl<ObjectType: Message> NSMutableArray<ObjectType> {
     /// Insert an object into the array at the given index.
     ///
     /// # Panics
     ///
     /// Panics if the index is out of bounds.
     #[doc(alias = "insertObject:atIndex:")]
-    pub fn insert(&self, index: usize, obj: &T) {
+    pub fn insert(&self, index: usize, obj: &ObjectType) {
         // TODO: Replace this check with catching the thrown NSRangeException
         let len = self.len();
         if index < len {
@@ -291,13 +291,13 @@ impl<T: Message> NSMutableArray<T> {
     /// Sort the array by the given comparison closure.
     #[cfg(feature = "NSObjCRuntime")]
     #[doc(alias = "sortUsingFunction:context:")]
-    pub fn sort_by<F: FnMut(&T, &T) -> core::cmp::Ordering>(&self, compare: F) {
+    pub fn sort_by<F: FnMut(&ObjectType, &ObjectType) -> core::cmp::Ordering>(&self, compare: F) {
         unsafe extern "C-unwind" fn compare_with_closure<
-            T,
-            F: FnMut(&T, &T) -> core::cmp::Ordering,
+            ObjectType,
+            F: FnMut(&ObjectType, &ObjectType) -> core::cmp::Ordering,
         >(
-            obj1: core::ptr::NonNull<T>,
-            obj2: core::ptr::NonNull<T>,
+            obj1: core::ptr::NonNull<ObjectType>,
+            obj2: core::ptr::NonNull<ObjectType>,
             context: *mut core::ffi::c_void,
         ) -> isize {
             let context: *mut F = context.cast();
@@ -313,7 +313,7 @@ impl<T: Message> NSMutableArray<T> {
         }
 
         // Create function pointer
-        let f: unsafe extern "C-unwind" fn(_, _, _) -> _ = compare_with_closure::<T, F>;
+        let f: unsafe extern "C-unwind" fn(_, _, _) -> _ = compare_with_closure::<ObjectType, F>;
 
         // Grab a type-erased pointer to the closure (a pointer to stack).
         let mut closure = compare;
@@ -326,8 +326,8 @@ impl<T: Message> NSMutableArray<T> {
 }
 
 #[cfg(feature = "NSEnumerator")]
-unsafe impl<T: Message> iter::FastEnumerationHelper for NSArray<T> {
-    type Item = T;
+unsafe impl<ObjectType: Message> iter::FastEnumerationHelper for NSArray<ObjectType> {
+    type Item = ObjectType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -336,8 +336,8 @@ unsafe impl<T: Message> iter::FastEnumerationHelper for NSArray<T> {
 }
 
 #[cfg(feature = "NSEnumerator")]
-unsafe impl<T: Message> iter::FastEnumerationHelper for NSMutableArray<T> {
-    type Item = T;
+unsafe impl<ObjectType: Message> iter::FastEnumerationHelper for NSMutableArray<ObjectType> {
+    type Item = ObjectType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -348,11 +348,11 @@ unsafe impl<T: Message> iter::FastEnumerationHelper for NSMutableArray<T> {
 /// An iterator over the items of an array.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct Iter<'a, T: Message>(iter::Iter<'a, NSArray<T>>);
+pub struct Iter<'a, ObjectType: Message>(iter::Iter<'a, NSArray<ObjectType>>);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = Retained<T>> for Iter<'a, T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = Retained<ObjectType>> for Iter<'a, ObjectType> { ... }
 }
 
 /// An iterator over unretained items of an array.
@@ -362,46 +362,46 @@ __impl_iter! {
 /// The array must not be mutated while this is alive.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct IterUnchecked<'a, T: Message>(iter::IterUnchecked<'a, NSArray<T>>);
+pub struct IterUnchecked<'a, ObjectType: Message>(iter::IterUnchecked<'a, NSArray<ObjectType>>);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = &'a T> for IterUnchecked<'a, T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = &'a ObjectType> for IterUnchecked<'a, ObjectType> { ... }
 }
 
 /// A retained iterator over the items of an array.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct IntoIter<T: Message>(iter::IntoIter<NSArray<T>>);
+pub struct IntoIter<ObjectType: Message>(iter::IntoIter<NSArray<ObjectType>>);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<T: Message> Iterator<Item = Retained<T>> for IntoIter<T> { ... }
+    impl<ObjectType: Message> Iterator<Item = Retained<ObjectType>> for IntoIter<ObjectType> { ... }
 }
 
 #[cfg(feature = "NSEnumerator")]
 __impl_into_iter! {
-    impl<T: Message> IntoIterator for &NSArray<T> {
-        type IntoIter = Iter<'_, T>;
+    impl<ObjectType: Message> IntoIterator for &NSArray<ObjectType> {
+        type IntoIter = Iter<'_, ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for &NSMutableArray<T> {
-        type IntoIter = Iter<'_, T>;
+    impl<ObjectType: Message> IntoIterator for &NSMutableArray<ObjectType> {
+        type IntoIter = Iter<'_, ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for Retained<NSArray<T>> {
+    impl<ObjectType: Message> IntoIterator for Retained<NSArray<ObjectType>> {
         #[uses(new)]
-        type IntoIter = IntoIter<T>;
+        type IntoIter = IntoIter<ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for Retained<NSMutableArray<T>> {
+    impl<ObjectType: Message> IntoIterator for Retained<NSMutableArray<ObjectType>> {
         #[uses(new_mutable)]
-        type IntoIter = IntoIter<T>;
+        type IntoIter = IntoIter<ObjectType>;
     }
 }
 
 #[cfg(feature = "NSEnumerator")]
-impl<T: fmt::Debug + Message> fmt::Debug for NSArray<T> {
+impl<ObjectType: fmt::Debug + Message> fmt::Debug for NSArray<ObjectType> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self).finish()
@@ -409,49 +409,53 @@ impl<T: fmt::Debug + Message> fmt::Debug for NSArray<T> {
 }
 
 #[cfg(feature = "NSEnumerator")]
-impl<T: fmt::Debug + Message> fmt::Debug for NSMutableArray<T> {
+impl<ObjectType: fmt::Debug + Message> fmt::Debug for NSMutableArray<ObjectType> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&**self, f)
     }
 }
 
-impl<T: Message> Extend<Retained<T>> for &NSMutableArray<T> {
-    fn extend<I: IntoIterator<Item = Retained<T>>>(&mut self, iter: I) {
+impl<ObjectType: Message> Extend<Retained<ObjectType>> for &NSMutableArray<ObjectType> {
+    fn extend<I: IntoIterator<Item = Retained<ObjectType>>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |item| self.addObject(&item));
     }
 }
 
-impl<'a, T: Message> Extend<&'a T> for &NSMutableArray<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
+impl<'a, ObjectType: Message> Extend<&'a ObjectType> for &NSMutableArray<ObjectType> {
+    fn extend<I: IntoIterator<Item = &'a ObjectType>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |item| self.addObject(item));
     }
 }
 
-impl<'a, T: Message + 'a> RetainedFromIterator<&'a T> for NSArray<T> {
-    fn retained_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Retained<Self> {
+impl<'a, ObjectType: Message + 'a> RetainedFromIterator<&'a ObjectType> for NSArray<ObjectType> {
+    fn retained_from_iter<I: IntoIterator<Item = &'a ObjectType>>(iter: I) -> Retained<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
     }
 }
 
-impl<T: Message> RetainedFromIterator<Retained<T>> for NSArray<T> {
-    fn retained_from_iter<I: IntoIterator<Item = Retained<T>>>(iter: I) -> Retained<Self> {
+impl<ObjectType: Message> RetainedFromIterator<Retained<ObjectType>> for NSArray<ObjectType> {
+    fn retained_from_iter<I: IntoIterator<Item = Retained<ObjectType>>>(iter: I) -> Retained<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_retained_slice(&vec)
     }
 }
 
-impl<'a, T: Message + 'a> RetainedFromIterator<&'a T> for NSMutableArray<T> {
-    fn retained_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Retained<Self> {
+impl<'a, ObjectType: Message + 'a> RetainedFromIterator<&'a ObjectType>
+    for NSMutableArray<ObjectType>
+{
+    fn retained_from_iter<I: IntoIterator<Item = &'a ObjectType>>(iter: I) -> Retained<Self> {
         // TODO: Is this, or is using `initWithCapacity` the most optimal?
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
     }
 }
 
-impl<T: Message> RetainedFromIterator<Retained<T>> for NSMutableArray<T> {
-    fn retained_from_iter<I: IntoIterator<Item = Retained<T>>>(iter: I) -> Retained<Self> {
+impl<ObjectType: Message> RetainedFromIterator<Retained<ObjectType>>
+    for NSMutableArray<ObjectType>
+{
+    fn retained_from_iter<I: IntoIterator<Item = Retained<ObjectType>>>(iter: I) -> Retained<Self> {
         // TODO: Is this, or is using `initWithCapacity` the most optimal?
         let vec = Vec::from_iter(iter);
         Self::from_retained_slice(&vec)
diff --git a/framework-crates/objc2-foundation/src/dictionary.rs b/framework-crates/objc2-foundation/src/dictionary.rs
index 579f0d7d0..abc4f34fc 100644
--- a/framework-crates/objc2-foundation/src/dictionary.rs
+++ b/framework-crates/objc2-foundation/src/dictionary.rs
@@ -19,19 +19,19 @@ use crate::{util, CopyingHelper, NSCopying};
 use crate::{NSDictionary, NSMutableDictionary};
 
 #[cfg(feature = "NSObject")]
-fn keys_to_ptr<Q>(keys: &[&Q]) -> *mut NonNull<ProtocolObject<dyn NSCopying>>
+fn keys_to_ptr<CopiedKey>(keys: &[&CopiedKey]) -> *mut NonNull<ProtocolObject<dyn NSCopying>>
 where
-    Q: Message + NSCopying,
+    CopiedKey: Message + NSCopying,
 {
-    let keys: *mut NonNull<Q> = util::ref_ptr_cast_const(keys.as_ptr());
-    // SAFETY: `Q` is `Message + NSCopying`, and is therefore safe to cast to
+    let keys: *mut NonNull<CopiedKey> = util::ref_ptr_cast_const(keys.as_ptr());
+    // SAFETY: `CopiedKey` is `Message + NSCopying`, and is therefore safe to cast to
     // `ProtocolObject<dyn NSCopying>`.
     let keys: *mut NonNull<ProtocolObject<dyn NSCopying>> = keys.cast();
     keys
 }
 
 /// Convenience creation methods.
-impl<K: Message, V: Message> NSDictionary<K, V> {
+impl<KeyType: Message, ObjectType: Message> NSDictionary<KeyType, ObjectType> {
     /// Create a new dictionary from a slice of keys, and a slice of objects.
     ///
     /// This is a safe interface to `initWithObjects:forKeys:count:`.
@@ -54,13 +54,13 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     /// assert_eq!(&*dict.objectForKey(ns_string!("key2")).unwrap(), ns_string!("value2"));
     /// ```
     #[cfg(feature = "NSObject")]
-    pub fn from_slices<Q>(keys: &[&Q], objects: &[&V]) -> Retained<Self>
+    pub fn from_slices<CopiedKey>(keys: &[&CopiedKey], objects: &[&ObjectType]) -> Retained<Self>
     where
         // The dictionary copies its keys, which is why we require `NSCopying`
-        // and use `CopyingHelper` on all input data - we want to ensure that the
-        // type-system knows that it's not actually e.g. `NSMutableString`
+        // and use `CopyingHelper` on all input data - we want to ensure that
+        // the type-system knows that it's not actually e.g. `NSMutableString`
         // that is being stored, but instead `NSString`.
-        Q: Message + NSCopying + CopyingHelper<Result = K>,
+        CopiedKey: Message + NSCopying + CopyingHelper<Result = KeyType>,
     {
         // Ensure that we don't read too far into one of the buffers.
         assert_eq!(
@@ -74,8 +74,9 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
         let objects = util::ref_ptr_cast_const(objects.as_ptr());
 
         // SAFETY:
-        // - All `T: Message` use interior mutability, and the dictionary
-        //   extends the lifetime of them internally by retaining them.
+        // - All types that are `Message` use interior mutability, and the
+        //   dictionary extends the lifetime of them internally by retaining
+        //   them.
         //
         // - The pointers are valid until the method has finished executing,
         //   at which point the dictionary will have created its own internal
@@ -95,9 +96,12 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     }
 
     #[cfg(feature = "NSObject")]
-    pub fn from_retained_objects<Q>(keys: &[&Q], objects: &[Retained<V>]) -> Retained<Self>
+    pub fn from_retained_objects<CopiedKey>(
+        keys: &[&CopiedKey],
+        objects: &[Retained<ObjectType>],
+    ) -> Retained<Self>
     where
-        Q: Message + NSCopying + CopyingHelper<Result = K>,
+        CopiedKey: Message + NSCopying + CopyingHelper<Result = KeyType>,
     {
         // Ensure that we don't read too far into one of the buffers.
         assert_eq!(
@@ -116,11 +120,11 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
 }
 
 /// Convenience creation methods.
-impl<K: Message, V: Message> NSMutableDictionary<K, V> {
+impl<KeyType: Message, ObjectType: Message> NSMutableDictionary<KeyType, ObjectType> {
     #[cfg(feature = "NSObject")]
-    pub fn from_slices<Q>(keys: &[&Q], objects: &[&V]) -> Retained<Self>
+    pub fn from_slices<CopiedKey>(keys: &[&CopiedKey], objects: &[&ObjectType]) -> Retained<Self>
     where
-        Q: Message + NSCopying + CopyingHelper<Result = K>,
+        CopiedKey: Message + NSCopying + CopyingHelper<Result = KeyType>,
     {
         // Ensure that we don't read too far into one of the buffers.
         assert_eq!(
@@ -138,9 +142,12 @@ impl<K: Message, V: Message> NSMutableDictionary<K, V> {
     }
 
     #[cfg(feature = "NSObject")]
-    pub fn from_retained_objects<Q>(keys: &[&Q], objects: &[Retained<V>]) -> Retained<Self>
+    pub fn from_retained_objects<CopiedKey>(
+        keys: &[&CopiedKey],
+        objects: &[Retained<ObjectType>],
+    ) -> Retained<Self>
     where
-        Q: Message + NSCopying + CopyingHelper<Result = K>,
+        CopiedKey: Message + NSCopying + CopyingHelper<Result = KeyType>,
     {
         // Ensure that we don't read too far into one of the buffers.
         assert_eq!(
@@ -158,15 +165,15 @@ impl<K: Message, V: Message> NSMutableDictionary<K, V> {
     }
 }
 
-// Note: We'd like to make getter methods take `K: Borrow<Q>` like
-// `std::collections::HashMap`, so that e.g. `NSDictionary<NSString, ...>`
+// Note: We'd like to make getter methods take `KeyType: Borrow<KeyType>`
+// like `std::collections::HashMap`, so that e.g. `NSDictionary<NSString, V>`
 // could take a `&NSObject` as input, and still make that work since
 // `NSString` borrows to `NSObject`.
 //
 // But we can't really, at least not with extra `unsafe` / an extra trait,
 // since we don't control how the comparisons happen.
 //
-// The most useful alternative would probably be to take `impl AsRef<K>`, but
+// The most useful alternative would probably be to take `impl AsRef<KeyType>`, but
 // objc2 classes deref to their superclass anyhow, so let's just use a simple,
 // normal reference.
 
@@ -182,7 +189,7 @@ impl<K: Message, V: Message> NSMutableDictionary<K, V> {
 /// accessing a deallocated object.
 ///
 /// [collections-own]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmPractical.html#//apple_ref/doc/uid/TP40004447-SW12
-impl<K: Message, V: Message> NSDictionary<K, V> {
+impl<KeyType: Message, ObjectType: Message> NSDictionary<KeyType, ObjectType> {
     /// Get a direct reference to the object corresponding to the key.
     ///
     /// Consider using the [`objectForKey`](Self::objectForKey) method
@@ -193,7 +200,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     /// The dictionary must not be mutated while the reference is live.
     #[doc(alias = "objectForKey:")]
     #[inline]
-    pub unsafe fn objectForKey_unchecked(&self, key: &K) -> Option<&V> {
+    pub unsafe fn objectForKey_unchecked(&self, key: &KeyType) -> Option<&ObjectType> {
         unsafe { msg_send![self, objectForKey: key] }
     }
 
@@ -208,7 +215,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     /// The dictionary must not be mutated while the returned references are
     /// alive.
     #[doc(alias = "getObjects:andKeys:")]
-    pub unsafe fn to_vecs_unchecked(&self) -> (Vec<&K>, Vec<&V>) {
+    pub unsafe fn to_vecs_unchecked(&self) -> (Vec<&KeyType>, Vec<&ObjectType>) {
         let len = self.len();
         let mut keys = Vec::with_capacity(len);
         let mut objs = Vec::with_capacity(len);
@@ -231,8 +238,8 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
         // lifetime is upheld by the caller.
         unsafe {
             (
-                mem::transmute::<Vec<NonNull<K>>, Vec<&K>>(keys),
-                mem::transmute::<Vec<NonNull<V>>, Vec<&V>>(objs),
+                mem::transmute::<Vec<NonNull<KeyType>>, Vec<&KeyType>>(keys),
+                mem::transmute::<Vec<NonNull<ObjectType>>, Vec<&ObjectType>>(objs),
             )
         }
     }
@@ -249,7 +256,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "keyEnumerator")]
     #[inline]
-    pub unsafe fn keys_unchecked(&self) -> KeysUnchecked<'_, K, V> {
+    pub unsafe fn keys_unchecked(&self) -> KeysUnchecked<'_, KeyType, ObjectType> {
         KeysUnchecked(iter::IterUnchecked::new(self))
     }
 
@@ -265,7 +272,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "objectEnumerator")]
     #[inline]
-    pub unsafe fn objects_unchecked(&self) -> ObjectsUnchecked<'_, K, V> {
+    pub unsafe fn objects_unchecked(&self) -> ObjectsUnchecked<'_, KeyType, ObjectType> {
         // SAFETY: Avoiding mutation is upheld by caller.
         let enumerator = unsafe { self.objectEnumerator() };
         // SAFETY: The enumerator came from the dictionary.
@@ -274,7 +281,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
 }
 
 /// Various accessor methods.
-impl<K: Message, V: Message> NSDictionary<K, V> {
+impl<KeyType: Message, ObjectType: Message> NSDictionary<KeyType, ObjectType> {
     /// The amount of elements in the dictionary.
     #[doc(alias = "count")]
     #[inline]
@@ -307,13 +314,13 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     /// }
     /// ```
     #[doc(alias = "getObjects:")]
-    pub fn to_vecs(&self) -> (Vec<Retained<K>>, Vec<Retained<V>>) {
+    pub fn to_vecs(&self) -> (Vec<Retained<KeyType>>, Vec<Retained<ObjectType>>) {
         // SAFETY: We retain the elements below, so that we know that the
         // dictionary isn't mutated while they are alive.
         let (keys, objects) = unsafe { self.to_vecs_unchecked() };
         (
-            keys.into_iter().map(K::retain).collect(),
-            objects.into_iter().map(V::retain).collect(),
+            keys.into_iter().map(KeyType::retain).collect(),
+            objects.into_iter().map(ObjectType::retain).collect(),
         )
     }
 
@@ -321,7 +328,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "keyEnumerator")]
     #[inline]
-    pub fn keys(&self) -> Keys<'_, K, V> {
+    pub fn keys(&self) -> Keys<'_, KeyType, ObjectType> {
         Keys(iter::Iter::new(self))
     }
 
@@ -343,7 +350,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "objectEnumerator")]
     #[inline]
-    pub fn objects(&self) -> Objects<'_, K, V> {
+    pub fn objects(&self) -> Objects<'_, KeyType, ObjectType> {
         // SAFETY: The iterator checks for mutation while enumerating.
         let enumerator = unsafe { self.objectEnumerator() };
         // SAFETY: The enumerator came from the dictionary.
@@ -352,7 +359,7 @@ impl<K: Message, V: Message> NSDictionary<K, V> {
 }
 
 /// Convenience mutation methods.
-impl<K: Message, V: Message> NSMutableDictionary<K, V> {
+impl<KeyType: Message, ObjectType: Message> NSMutableDictionary<KeyType, ObjectType> {
     /// Inserts a key-value pair into the dictionary.
     ///
     /// If the dictionary did not have this key present, the value is
@@ -370,20 +377,22 @@ impl<K: Message, V: Message> NSMutableDictionary<K, V> {
     #[cfg(feature = "NSObject")]
     #[doc(alias = "setObject:forKey:")]
     #[inline]
-    pub fn insert<Q>(&self, key: &Q, object: &V)
+    pub fn insert<CopiedKey>(&self, key: &CopiedKey, object: &ObjectType)
     where
-        Q: Message + NSCopying + CopyingHelper<Result = K>,
+        CopiedKey: Message + NSCopying + CopyingHelper<Result = KeyType>,
     {
         let key = ProtocolObject::from_ref(key);
-        // SAFETY: The key is copied, and then has the correct type `K`.
+        // SAFETY: The key is copied, and then has the correct type `KeyType`.
         unsafe { self.setObject_forKey(object, key) };
     }
 }
 
 #[cfg(feature = "NSEnumerator")]
-unsafe impl<K: Message, V: Message> iter::FastEnumerationHelper for NSDictionary<K, V> {
+unsafe impl<KeyType: Message, ObjectType: Message> iter::FastEnumerationHelper
+    for NSDictionary<KeyType, ObjectType>
+{
     // Fast enumeration for dictionaries returns the keys.
-    type Item = K;
+    type Item = KeyType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -392,9 +401,11 @@ unsafe impl<K: Message, V: Message> iter::FastEnumerationHelper for NSDictionary
 }
 
 #[cfg(feature = "NSEnumerator")]
-unsafe impl<K: Message, V: Message> iter::FastEnumerationHelper for NSMutableDictionary<K, V> {
+unsafe impl<KeyType: Message, ObjectType: Message> iter::FastEnumerationHelper
+    for NSMutableDictionary<KeyType, ObjectType>
+{
     // The same goes for mutable dictionaries.
-    type Item = K;
+    type Item = KeyType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -405,11 +416,13 @@ unsafe impl<K: Message, V: Message> iter::FastEnumerationHelper for NSMutableDic
 /// An iterator over the keys of a dictionary.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct Keys<'a, K: Message, V: Message>(iter::Iter<'a, NSDictionary<K, V>>);
+pub struct Keys<'a, KeyType: Message, ObjectType: Message>(
+    iter::Iter<'a, NSDictionary<KeyType, ObjectType>>,
+);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, K: Message, V: Message> Iterator<Item = Retained<K>> for Keys<'a, K, V> { ... }
+    impl<'a, KeyType: Message, ObjectType: Message> Iterator<Item = Retained<KeyType>> for Keys<'a, KeyType, ObjectType> { ... }
 }
 
 /// An iterator over unretained keys of a dictionary.
@@ -419,23 +432,29 @@ __impl_iter! {
 /// The dictionary must not be mutated while this is alive.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct KeysUnchecked<'a, K: Message, V: Message>(iter::IterUnchecked<'a, NSDictionary<K, V>>);
+pub struct KeysUnchecked<'a, KeyType: Message, ObjectType: Message>(
+    iter::IterUnchecked<'a, NSDictionary<KeyType, ObjectType>>,
+);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, K: Message, V: Message> Iterator<Item = &'a K> for KeysUnchecked<'a, K, V> { ... }
+    impl<'a, KeyType: Message, ObjectType: Message> Iterator<Item = &'a KeyType> for KeysUnchecked<'a, KeyType, ObjectType> { ... }
 }
 
 /// An iterator over the objects / values in a dictionary.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct Objects<'a, K: Message, V: Message>(
-    iter::IterWithBackingEnum<'a, NSDictionary<K, V>, crate::NSEnumerator<V>>,
+pub struct Objects<'a, KeyType: Message, ObjectType: Message>(
+    iter::IterWithBackingEnum<
+        'a,
+        NSDictionary<KeyType, ObjectType>,
+        crate::NSEnumerator<ObjectType>,
+    >,
 );
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, K: Message, V: Message> Iterator<Item = Retained<V>> for Objects<'a, K, V> { ... }
+    impl<'a, KeyType: Message, ObjectType: Message> Iterator<Item = Retained<ObjectType>> for Objects<'a, KeyType, ObjectType> { ... }
 }
 
 /// An iterator over unretained objects / values of a dictionary.
@@ -445,16 +464,22 @@ __impl_iter! {
 /// The dictionary must not be mutated while this is alive.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct ObjectsUnchecked<'a, K: Message, V: Message + 'a>(
-    iter::IterUncheckedWithBackingEnum<'a, NSDictionary<K, V>, crate::NSEnumerator<V>>,
+pub struct ObjectsUnchecked<'a, KeyType: Message, ObjectType: Message + 'a>(
+    iter::IterUncheckedWithBackingEnum<
+        'a,
+        NSDictionary<KeyType, ObjectType>,
+        crate::NSEnumerator<ObjectType>,
+    >,
 );
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, K: Message, V: Message> Iterator<Item = &'a V> for ObjectsUnchecked<'a, K, V> { ... }
+    impl<'a, KeyType: Message, ObjectType: Message> Iterator<Item = &'a ObjectType> for ObjectsUnchecked<'a, KeyType, ObjectType> { ... }
 }
 
-impl<K: fmt::Debug + Message, V: fmt::Debug + Message> fmt::Debug for NSDictionary<K, V> {
+impl<KeyType: fmt::Debug + Message, ObjectType: fmt::Debug + Message> fmt::Debug
+    for NSDictionary<KeyType, ObjectType>
+{
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // SAFETY: Unsound, use `to_vecs` instead when that doesn't have extra bounds
@@ -464,7 +489,9 @@ impl<K: fmt::Debug + Message, V: fmt::Debug + Message> fmt::Debug for NSDictiona
     }
 }
 
-impl<K: fmt::Debug + Message, V: fmt::Debug + Message> fmt::Debug for NSMutableDictionary<K, V> {
+impl<KeyType: fmt::Debug + Message, ObjectType: fmt::Debug + Message> fmt::Debug
+    for NSMutableDictionary<KeyType, ObjectType>
+{
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&**self, f)
diff --git a/framework-crates/objc2-foundation/src/enumerator.rs b/framework-crates/objc2-foundation/src/enumerator.rs
index 3fd67d9d7..6b2d61344 100644
--- a/framework-crates/objc2-foundation/src/enumerator.rs
+++ b/framework-crates/objc2-foundation/src/enumerator.rs
@@ -6,19 +6,19 @@ use crate::{iter, NSEnumerator};
 
 // TODO: Measure whether iterating through `nextObject` or fast enumeration is
 // fastest.
-// impl<T: Message> Iterator for NSEnumerator<T> {
-//     type Item = Retained<T>;
+// impl<ObjectType: Message> Iterator for NSEnumerator<ObjectType> {
+//     type Item = Retained<ObjectType>;
 //
 //     #[inline]
-//     fn next(&mut self) -> Option<Retained<T>> {
+//     fn next(&mut self) -> Option<Retained<ObjectType>> {
 //         self.nextObject()
 //     }
 // }
 
-impl<T: Message> NSEnumerator<T> {
+impl<ObjectType: Message> NSEnumerator<ObjectType> {
     /// Iterate over the enumerator's elements.
     #[inline]
-    pub fn iter(&self) -> Iter<'_, T> {
+    pub fn iter(&self) -> Iter<'_, ObjectType> {
         Iter(iter::Iter::new(self))
     }
 
@@ -32,13 +32,13 @@ impl<T: Message> NSEnumerator<T> {
     /// The enumerator and the underlying collection must not be mutated while
     /// the iterator is alive.
     #[inline]
-    pub unsafe fn iter_unchecked(&self) -> IterUnchecked<'_, T> {
+    pub unsafe fn iter_unchecked(&self) -> IterUnchecked<'_, ObjectType> {
         IterUnchecked(iter::IterUnchecked::new(self))
     }
 }
 
-unsafe impl<T: Message> iter::FastEnumerationHelper for NSEnumerator<T> {
-    type Item = T;
+unsafe impl<ObjectType: Message> iter::FastEnumerationHelper for NSEnumerator<ObjectType> {
+    type Item = ObjectType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -48,10 +48,10 @@ unsafe impl<T: Message> iter::FastEnumerationHelper for NSEnumerator<T> {
 
 /// An iterator over the items in an enumerator.
 #[derive(Debug)]
-pub struct Iter<'a, T: Message>(iter::Iter<'a, NSEnumerator<T>>);
+pub struct Iter<'a, ObjectType: Message>(iter::Iter<'a, NSEnumerator<ObjectType>>);
 
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = Retained<T>> for Iter<'a, T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = Retained<ObjectType>> for Iter<'a, ObjectType> { ... }
 }
 
 /// An iterator over unretained items in an enumerator.
@@ -61,28 +61,30 @@ __impl_iter! {
 /// The enumerator and the underlying collection must not be mutated while
 /// this is alive.
 #[derive(Debug)]
-pub struct IterUnchecked<'a, T: Message + 'a>(iter::IterUnchecked<'a, NSEnumerator<T>>);
+pub struct IterUnchecked<'a, ObjectType: Message + 'a>(
+    iter::IterUnchecked<'a, NSEnumerator<ObjectType>>,
+);
 
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = &'a T> for IterUnchecked<'a, T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = &'a ObjectType> for IterUnchecked<'a, ObjectType> { ... }
 }
 
 /// A consuming iterator over the items in an enumerator.
 #[derive(Debug)]
-pub struct IntoIter<T: Message>(iter::IntoIter<NSEnumerator<T>>);
+pub struct IntoIter<ObjectType: Message>(iter::IntoIter<NSEnumerator<ObjectType>>);
 
 __impl_iter! {
-    impl<T: Message> Iterator<Item = Retained<T>> for IntoIter<T> { ... }
+    impl<ObjectType: Message> Iterator<Item = Retained<ObjectType>> for IntoIter<ObjectType> { ... }
 }
 
 __impl_into_iter! {
-    impl<T: Message> IntoIterator for &NSEnumerator<T> {
-        type IntoIter = Iter<'_, T>;
+    impl<ObjectType: Message> IntoIterator for &NSEnumerator<ObjectType> {
+        type IntoIter = Iter<'_, ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for Retained<NSEnumerator<T>> {
+    impl<ObjectType: Message> IntoIterator for Retained<NSEnumerator<ObjectType>> {
         #[uses(new)]
-        type IntoIter = IntoIter<T>;
+        type IntoIter = IntoIter<ObjectType>;
     }
 }
 
diff --git a/framework-crates/objc2-foundation/src/iter.rs b/framework-crates/objc2-foundation/src/iter.rs
index 129b6a42a..9cdea1ca7 100644
--- a/framework-crates/objc2-foundation/src/iter.rs
+++ b/framework-crates/objc2-foundation/src/iter.rs
@@ -602,16 +602,16 @@ macro_rules! __impl_into_iter {
     () => {};
     (
         $(#[$m:meta])*
-        impl<T: Message> IntoIterator for &$ty:ident<T> {
-            type IntoIter = $iter:ident<'_, T>;
+        impl<$param:ident: Message> IntoIterator for &$ty:ident<$param2:ident> {
+            type IntoIter = $iter:ident<'_, $param3:ident>;
         }
 
         $($rest:tt)*
     ) => {
         $(#[$m])*
-        impl<'a, T: Message> IntoIterator for &'a $ty<T> {
-            type Item = Retained<T>;
-            type IntoIter = $iter<'a, T>;
+        impl<'a, $param: Message> IntoIterator for &'a $ty<$param2> {
+            type Item = Retained<$param3>;
+            type IntoIter = $iter<'a, $param3>;
 
             #[inline]
             fn into_iter(self) -> Self::IntoIter {
@@ -625,17 +625,17 @@ macro_rules! __impl_into_iter {
     };
     (
         $(#[$m:meta])*
-        impl<T: Message> IntoIterator for Retained<$ty:ident<T>> {
+        impl<$param:ident: Message> IntoIterator for Retained<$ty:ident<$param2:ident>> {
             #[uses($new_fn:ident)]
-            type IntoIter = $into_iter:ident<T>;
+            type IntoIter = $into_iter:ident<$param3:ident>;
         }
 
         $($rest:tt)*
     ) => {
         $(#[$m])*
-        impl<T: Message> objc2::rc::RetainedIntoIterator for $ty<T> {
-            type Item = Retained<T>;
-            type IntoIter = $into_iter<T>;
+        impl<$param: Message> objc2::rc::RetainedIntoIterator for $ty<$param2> {
+            type Item = Retained<$param3>;
+            type IntoIter = $into_iter<$param3>;
 
             #[inline]
             fn retained_into_iter(this: Retained<Self>) -> Self::IntoIter {
diff --git a/framework-crates/objc2-foundation/src/set.rs b/framework-crates/objc2-foundation/src/set.rs
index ba3ce4cbd..835fe4b5d 100644
--- a/framework-crates/objc2-foundation/src/set.rs
+++ b/framework-crates/objc2-foundation/src/set.rs
@@ -11,7 +11,7 @@ use crate::iter;
 use crate::{util, NSMutableSet, NSSet};
 
 /// Convenience creation methods.
-impl<T: Message> NSSet<T> {
+impl<ObjectType: Message> NSSet<ObjectType> {
     /// Creates an [`NSSet`] from a slice of `Retained`s.
     ///
     /// # Examples
@@ -22,14 +22,14 @@ impl<T: Message> NSSet<T> {
     /// let strs = ["one", "two", "three"].map(NSString::from_str);
     /// let set = NSSet::from_retained_slice(&strs);
     /// ```
-    pub fn from_retained_slice(slice: &[Retained<T>]) -> Retained<Self> {
+    pub fn from_retained_slice(slice: &[Retained<ObjectType>]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::retained_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `NSArray::from_retained_slice`
         unsafe { Self::initWithObjects_count(Self::alloc(), ptr, len) }
     }
 
-    pub fn from_slice(slice: &[&T]) -> Retained<Self> {
+    pub fn from_slice(slice: &[&ObjectType]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::ref_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `NSArray::from_slice`.
@@ -38,7 +38,7 @@ impl<T: Message> NSSet<T> {
 }
 
 /// Convenience creation methods.
-impl<T: Message> NSMutableSet<T> {
+impl<ObjectType: Message> NSMutableSet<ObjectType> {
     /// Creates an [`NSMutableSet`] from a slice of `Retained`s.
     ///
     /// # Examples
@@ -49,14 +49,14 @@ impl<T: Message> NSMutableSet<T> {
     /// let strs = ["one", "two", "three"].map(NSString::from_str);
     /// let set = NSMutableSet::from_retained_slice(&strs);
     /// ```
-    pub fn from_retained_slice(slice: &[Retained<T>]) -> Retained<Self> {
+    pub fn from_retained_slice(slice: &[Retained<ObjectType>]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::retained_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `NSArray::from_retained_slice`
         unsafe { Self::initWithObjects_count(Self::alloc(), ptr, len) }
     }
 
-    pub fn from_slice(slice: &[&T]) -> Retained<Self> {
+    pub fn from_slice(slice: &[&ObjectType]) -> Retained<Self> {
         let len = slice.len();
         let ptr = util::ref_ptr_cast_const(slice.as_ptr());
         // SAFETY: Same as `NSArray::from_slice`.
@@ -75,7 +75,7 @@ impl<T: Message> NSMutableSet<T> {
 /// doing so - otherwise, we might end up accessing a deallocated object.
 ///
 /// [collections-own]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmPractical.html#//apple_ref/doc/uid/TP40004447-SW12
-impl<T: Message> NSSet<T> {
+impl<ObjectType: Message> NSSet<ObjectType> {
     /// A direct reference to an arbitrary object in the set.
     ///
     /// Consider using the [`anyObject`](Self::anyObject) method instead,
@@ -85,7 +85,7 @@ impl<T: Message> NSSet<T> {
     ///
     /// The set must not be mutated while the reference is live.
     #[doc(alias = "anyObject")]
-    pub unsafe fn anyObject_unchecked(&self) -> Option<&T> {
+    pub unsafe fn anyObject_unchecked(&self) -> Option<&ObjectType> {
         // SAFETY: Upheld by caller.
         unsafe { msg_send![self, anyObject] }
     }
@@ -99,7 +99,7 @@ impl<T: Message> NSSet<T> {
     ///
     /// The set must not be mutated while the returned reference is live.
     #[doc(alias = "member:")]
-    pub unsafe fn member_unchecked(&self, object: &T) -> Option<&T> {
+    pub unsafe fn member_unchecked(&self, object: &ObjectType) -> Option<&ObjectType> {
         // SAFETY: Upheld by caller.
         unsafe { msg_send![self, member: object] }
     }
@@ -117,13 +117,13 @@ impl<T: Message> NSSet<T> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "objectEnumerator")]
     #[inline]
-    pub unsafe fn iter_unchecked(&self) -> IterUnchecked<'_, T> {
+    pub unsafe fn iter_unchecked(&self) -> IterUnchecked<'_, ObjectType> {
         IterUnchecked(super::iter::IterUnchecked::new(self))
     }
 }
 
 /// Various accessor methods.
-impl<T: Message> NSSet<T> {
+impl<ObjectType: Message> NSSet<ObjectType> {
     /// Returns the number of elements in the set.
     ///
     /// # Examples
@@ -169,7 +169,7 @@ impl<T: Message> NSSet<T> {
     #[cfg(feature = "NSEnumerator")]
     #[doc(alias = "objectEnumerator")]
     #[inline]
-    pub fn iter(&self) -> Iter<'_, T> {
+    pub fn iter(&self) -> Iter<'_, ObjectType> {
         Iter(super::iter::Iter::new(self))
     }
 
@@ -190,14 +190,14 @@ impl<T: Message> NSSet<T> {
     /// assert_eq!(vec.len(), 3);
     /// ```
     #[cfg(feature = "NSEnumerator")]
-    pub fn to_vec(&self) -> Vec<Retained<T>> {
+    pub fn to_vec(&self) -> Vec<Retained<ObjectType>> {
         self.iter().collect()
     }
 }
 
 #[cfg(feature = "NSEnumerator")]
-unsafe impl<T: Message> iter::FastEnumerationHelper for NSSet<T> {
-    type Item = T;
+unsafe impl<ObjectType: Message> iter::FastEnumerationHelper for NSSet<ObjectType> {
+    type Item = ObjectType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -206,8 +206,8 @@ unsafe impl<T: Message> iter::FastEnumerationHelper for NSSet<T> {
 }
 
 #[cfg(feature = "NSEnumerator")]
-unsafe impl<T: Message> iter::FastEnumerationHelper for NSMutableSet<T> {
-    type Item = T;
+unsafe impl<ObjectType: Message> iter::FastEnumerationHelper for NSMutableSet<ObjectType> {
+    type Item = ObjectType;
 
     #[inline]
     fn maybe_len(&self) -> Option<usize> {
@@ -218,21 +218,21 @@ unsafe impl<T: Message> iter::FastEnumerationHelper for NSMutableSet<T> {
 /// An iterator over the items of a set.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct Iter<'a, T: Message>(iter::Iter<'a, NSSet<T>>);
+pub struct Iter<'a, ObjectType: Message>(iter::Iter<'a, NSSet<ObjectType>>);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = Retained<T>> for Iter<'a, T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = Retained<ObjectType>> for Iter<'a, ObjectType> { ... }
 }
 
 /// An unchecked iterator over the items of a set.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct IterUnchecked<'a, T: Message>(iter::IterUnchecked<'a, NSSet<T>>);
+pub struct IterUnchecked<'a, ObjectType: Message>(iter::IterUnchecked<'a, NSSet<ObjectType>>);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = &'a T> for IterUnchecked<'a, T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = &'a ObjectType> for IterUnchecked<'a, ObjectType> { ... }
 }
 
 /// An iterator over unretained items of a set.
@@ -242,36 +242,36 @@ __impl_iter! {
 /// The set must not be mutated while this is alive.
 #[derive(Debug)]
 #[cfg(feature = "NSEnumerator")]
-pub struct IntoIter<T: Message>(iter::IntoIter<NSSet<T>>);
+pub struct IntoIter<ObjectType: Message>(iter::IntoIter<NSSet<ObjectType>>);
 
 #[cfg(feature = "NSEnumerator")]
 __impl_iter! {
-    impl<'a, T: Message> Iterator<Item = Retained<T>> for IntoIter<T> { ... }
+    impl<'a, ObjectType: Message> Iterator<Item = Retained<ObjectType>> for IntoIter<ObjectType> { ... }
 }
 
 #[cfg(feature = "NSEnumerator")]
 __impl_into_iter! {
-    impl<T: Message> IntoIterator for &NSSet<T> {
-        type IntoIter = Iter<'_, T>;
+    impl<ObjectType: Message> IntoIterator for &NSSet<ObjectType> {
+        type IntoIter = Iter<'_, ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for &NSMutableSet<T> {
-        type IntoIter = Iter<'_, T>;
+    impl<ObjectType: Message> IntoIterator for &NSMutableSet<ObjectType> {
+        type IntoIter = Iter<'_, ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for Retained<NSSet<T>> {
+    impl<ObjectType: Message> IntoIterator for Retained<NSSet<ObjectType>> {
         #[uses(new)]
-        type IntoIter = IntoIter<T>;
+        type IntoIter = IntoIter<ObjectType>;
     }
 
-    impl<T: Message> IntoIterator for Retained<NSMutableSet<T>> {
+    impl<ObjectType: Message> IntoIterator for Retained<NSMutableSet<ObjectType>> {
         #[uses(new_mutable)]
-        type IntoIter = IntoIter<T>;
+        type IntoIter = IntoIter<ObjectType>;
     }
 }
 
 #[cfg(feature = "NSEnumerator")]
-impl<T: fmt::Debug + Message> fmt::Debug for NSSet<T> {
+impl<ObjectType: fmt::Debug + Message> fmt::Debug for NSSet<ObjectType> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_set().entries(self).finish()
@@ -279,7 +279,7 @@ impl<T: fmt::Debug + Message> fmt::Debug for NSSet<T> {
 }
 
 #[cfg(feature = "NSEnumerator")]
-impl<T: fmt::Debug + Message> fmt::Debug for NSMutableSet<T> {
+impl<ObjectType: fmt::Debug + Message> fmt::Debug for NSMutableSet<ObjectType> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&**self, f)
@@ -287,53 +287,55 @@ impl<T: fmt::Debug + Message> fmt::Debug for NSMutableSet<T> {
 }
 
 #[cfg(feature = "NSEnumerator")]
-impl<T: fmt::Debug + Message> fmt::Debug for crate::NSCountedSet<T> {
+impl<ObjectType: fmt::Debug + Message> fmt::Debug for crate::NSCountedSet<ObjectType> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&**self, f)
     }
 }
 
-impl<T: Message> Extend<Retained<T>> for &NSMutableSet<T> {
-    fn extend<I: IntoIterator<Item = Retained<T>>>(&mut self, iter: I) {
+impl<ObjectType: Message> Extend<Retained<ObjectType>> for &NSMutableSet<ObjectType> {
+    fn extend<I: IntoIterator<Item = Retained<ObjectType>>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |item| {
             self.addObject(&item);
         });
     }
 }
 
-impl<'a, T: Message> Extend<&'a T> for &NSMutableSet<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
+impl<'a, ObjectType: Message> Extend<&'a ObjectType> for &NSMutableSet<ObjectType> {
+    fn extend<I: IntoIterator<Item = &'a ObjectType>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |item| {
             self.addObject(item);
         });
     }
 }
 
-impl<'a, T: Message + 'a> RetainedFromIterator<&'a T> for NSSet<T> {
-    fn retained_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Retained<Self> {
+impl<'a, ObjectType: Message + 'a> RetainedFromIterator<&'a ObjectType> for NSSet<ObjectType> {
+    fn retained_from_iter<I: IntoIterator<Item = &'a ObjectType>>(iter: I) -> Retained<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
     }
 }
 
-impl<T: Message> RetainedFromIterator<Retained<T>> for NSSet<T> {
-    fn retained_from_iter<I: IntoIterator<Item = Retained<T>>>(iter: I) -> Retained<Self> {
+impl<ObjectType: Message> RetainedFromIterator<Retained<ObjectType>> for NSSet<ObjectType> {
+    fn retained_from_iter<I: IntoIterator<Item = Retained<ObjectType>>>(iter: I) -> Retained<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_retained_slice(&vec)
     }
 }
 
-impl<'a, T: Message + 'a> RetainedFromIterator<&'a T> for NSMutableSet<T> {
-    fn retained_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Retained<Self> {
+impl<'a, ObjectType: Message + 'a> RetainedFromIterator<&'a ObjectType>
+    for NSMutableSet<ObjectType>
+{
+    fn retained_from_iter<I: IntoIterator<Item = &'a ObjectType>>(iter: I) -> Retained<Self> {
         // TODO: Is this, or is using `initWithCapacity` the most optimal?
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
     }
 }
 
-impl<T: Message> RetainedFromIterator<Retained<T>> for NSMutableSet<T> {
-    fn retained_from_iter<I: IntoIterator<Item = Retained<T>>>(iter: I) -> Retained<Self> {
+impl<ObjectType: Message> RetainedFromIterator<Retained<ObjectType>> for NSMutableSet<ObjectType> {
+    fn retained_from_iter<I: IntoIterator<Item = Retained<ObjectType>>>(iter: I) -> Retained<Self> {
         // TODO: Is this, or is using `initWithCapacity` the most optimal?
         let vec = Vec::from_iter(iter);
         Self::from_retained_slice(&vec)
diff --git a/framework-crates/objc2-foundation/src/to_owned.rs b/framework-crates/objc2-foundation/src/to_owned.rs
index a94795c50..7560ca492 100644
--- a/framework-crates/objc2-foundation/src/to_owned.rs
+++ b/framework-crates/objc2-foundation/src/to_owned.rs
@@ -7,7 +7,7 @@ use objc2::Message;
 use crate::{NSCopying, NSMutableCopying};
 
 #[cfg(feature = "NSArray")]
-impl<T: Message> ToOwned for crate::NSArray<T> {
+impl<ObjectType: Message> ToOwned for crate::NSArray<ObjectType> {
     type Owned = Retained<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.copy()
@@ -15,7 +15,7 @@ impl<T: Message> ToOwned for crate::NSArray<T> {
 }
 
 #[cfg(feature = "NSArray")]
-impl<T: Message> ToOwned for crate::NSMutableArray<T> {
+impl<ObjectType: Message> ToOwned for crate::NSMutableArray<ObjectType> {
     type Owned = Retained<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.mutableCopy()
@@ -47,7 +47,7 @@ impl ToOwned for crate::NSException {
 }
 
 #[cfg(feature = "NSSet")]
-impl<T: Message> ToOwned for crate::NSSet<T> {
+impl<ObjectType: Message> ToOwned for crate::NSSet<ObjectType> {
     type Owned = Retained<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.copy()
@@ -55,7 +55,7 @@ impl<T: Message> ToOwned for crate::NSSet<T> {
 }
 
 #[cfg(feature = "NSSet")]
-impl<T: Message> ToOwned for crate::NSMutableSet<T> {
+impl<ObjectType: Message> ToOwned for crate::NSMutableSet<ObjectType> {
     type Owned = Retained<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.mutableCopy()