Rename ClassDecl to ClassBuilder to be more in line with Rust naming

Also `ProtocolDecl` to `ProtocolBuilder`

Author: madsmtm

objc2-foundation/examples/class_with_lifetime.rs

@@ -2,7 +2,7 @@
 use std::marker::PhantomData;
 use std::sync::Once;
 
-use objc2::declare::ClassDecl;
+use objc2::declare::ClassBuilder;
 use objc2::rc::{Id, Owned, Shared};
 use objc2::runtime::{Class, Object, Sel};
 use objc2::{msg_send, sel};
@@ -48,8 +48,8 @@ impl<'a> MyObject<'a> {
     fn class() -> &'static Class {
         MYOBJECT_REGISTER_CLASS.call_once(|| {
             let superclass = NSObject::class();
-            let mut decl = ClassDecl::new("MyObject", superclass).unwrap();
-            decl.add_ivar::<Option<&mut u8>>("_number_ptr");
+            let mut builder = ClassBuilder::new("MyObject", superclass).unwrap();
+            builder.add_ivar::<Option<&mut u8>>("_number_ptr");
 
             unsafe extern "C" fn init_with_ptr(
                 this: *mut Object,
@@ -68,10 +68,10 @@ impl<'a> MyObject<'a> {
             unsafe {
                 let init_with_ptr: unsafe extern "C" fn(*mut Object, Sel, *mut u8) -> *mut Object =
                     init_with_ptr;
-                decl.add_method(sel!(initWithPtr:), init_with_ptr);
+                builder.add_method(sel!(initWithPtr:), init_with_ptr);
             }
 
-            decl.register();
+            builder.register();
         });
 
         Class::get("MyObject").unwrap()

objc2-foundation/examples/custom_class.rs

@@ -1,6 +1,6 @@
 use std::sync::Once;
 
-use objc2::declare::ClassDecl;
+use objc2::declare::ClassBuilder;
 use objc2::rc::{Id, Owned};
 use objc2::runtime::{Class, Object, Sel};
 use objc2::{msg_send, sel};
@@ -39,8 +39,8 @@ impl MYObject {
     fn class() -> &'static Class {
         MYOBJECT_REGISTER_CLASS.call_once(|| {
             let superclass = NSObject::class();
-            let mut decl = ClassDecl::new("MYObject", superclass).unwrap();
-            decl.add_ivar::<u32>("_number");
+            let mut builder = ClassBuilder::new("MYObject", superclass).unwrap();
+            builder.add_ivar::<u32>("_number");
 
             // Add ObjC methods for getting and setting the number
             extern "C" fn my_object_set_number(this: &mut MYObject, _cmd: Sel, number: u32) {
@@ -53,12 +53,12 @@ impl MYObject {
 
             unsafe {
                 let set_number: extern "C" fn(&mut MYObject, Sel, u32) = my_object_set_number;
-                decl.add_method(sel!(setNumber:), set_number);
+                builder.add_method(sel!(setNumber:), set_number);
                 let get_number: extern "C" fn(&MYObject, Sel) -> u32 = my_object_get_number;
-                decl.add_method(sel!(number), get_number);
+                builder.add_method(sel!(number), get_number);
             }
 
-            decl.register();
+            builder.register();
         });
 
         Class::get("MYObject").unwrap()

objc2/CHANGELOG.md

@@ -36,6 +36,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   ```
 * Allow specifying any receiver `T: Message` for methods added with
   `ClassBuilder::add_method`.
+* Renamed `ClassDecl` and `ProtocolDecl` to `ClassBuilder` and
+  `ProtocolBuilder`. The old names are kept as deprecated aliases.
 
 ### Fixed
 * Properly sealed the `MessageArguments` trait (it already had a hidden

objc2/src/declare.rs

@@ -1,6 +1,6 @@
 //! Functionality for declaring Objective-C classes.
 //!
-//! Classes can be declared using the [`ClassDecl`] struct. Instance variables
+//! Classes can be declared using the [`ClassBuilder`] struct. Instance variables
 //! and methods can then be added before the class is ultimately registered.
 //!
 //! # Example
@@ -11,11 +11,11 @@
 //!
 //! ```no_run
 //! use objc2::{class, sel};
-//! use objc2::declare::ClassDecl;
+//! use objc2::declare::ClassBuilder;
 //! use objc2::runtime::{Class, Object, Sel};
 //!
 //! let superclass = class!(NSObject);
-//! let mut decl = ClassDecl::new("MyNumber", superclass).unwrap();
+//! let mut decl = ClassBuilder::new("MyNumber", superclass).unwrap();
 //!
 //! // Add an instance variable
 //! decl.add_ivar::<u32>("_number");
@@ -124,10 +124,14 @@ fn log2_align_of<T>() -> u8 {
 /// A type for declaring a new class and adding new methods and ivars to it
 /// before registering it.
 #[derive(Debug)]
-pub struct ClassDecl {
+pub struct ClassBuilder {
     cls: NonNull<Class>,
 }
 
+#[doc(hidden)]
+#[deprecated = "Use `ClassBuilder` instead."]
+pub type ClassDecl = ClassBuilder;
+
 // SAFETY: The stuff that touch global state does so using locks internally.
 //
 // Modifying the class itself can only be done through `&mut`, so Sync is
@@ -138,11 +142,11 @@ pub struct ClassDecl {
 // when doing so...).
 //
 // Finally, there are no requirements that the class must be registered on the
-// same thread that allocated it.
-unsafe impl Send for ClassDecl {}
-unsafe impl Sync for ClassDecl {}
+// same thread that allocated it (so Send is safe).
+unsafe impl Send for ClassBuilder {}
+unsafe impl Sync for ClassBuilder {}
 
-impl ClassDecl {
+impl ClassBuilder {
     fn as_ptr(&self) -> *mut ffi::objc_class {
         self.cls.as_ptr().cast()
     }
@@ -154,16 +158,16 @@ impl ClassDecl {
         NonNull::new(cls.cast()).map(|cls| Self { cls })
     }
 
-    /// Constructs a [`ClassDecl`] with the given name and superclass.
+    /// Constructs a [`ClassBuilder`] with the given name and superclass.
     ///
     /// Returns [`None`] if the class couldn't be allocated, or a class with
     /// that name already exist.
     pub fn new(name: &str, superclass: &Class) -> Option<Self> {
         Self::with_superclass(name, Some(superclass))
     }
 
-    /// Constructs a [`ClassDecl`] declaring a new root class with the given
-    /// name.
+    /// Constructs a [`ClassBuilder`] declaring a new root class with the
+    /// given name.
     ///
     /// Returns [`None`] if the class couldn't be allocated.
     ///
@@ -177,11 +181,10 @@ impl ClassDecl {
     /// Functionality it expects, like implementations of `-retain` and
     /// `-release` used by ARC, will not be present otherwise.
     pub fn root(name: &str, intitialize_fn: extern "C" fn(&Class, Sel)) -> Option<Self> {
-        let mut decl = Self::with_superclass(name, None);
-        if let Some(ref mut decl) = decl {
-            unsafe { decl.add_class_method(sel!(initialize), intitialize_fn) };
-        }
-        decl
+        Self::with_superclass(name, None).map(|mut this| {
+            unsafe { this.add_class_method(sel!(initialize), intitialize_fn) };
+            this
+        })
     }
 
     /// Adds a method with the given name and implementation.
@@ -295,8 +298,8 @@ impl ClassDecl {
 
     // fn add_property(&self, name: &str, attributes: &[ffi::objc_property_attribute_t]);
 
-    /// Registers the [`ClassDecl`], consuming it, and returns a reference to
-    /// the newly registered [`Class`].
+    /// Registers the [`ClassBuilder`], consuming it, and returns a reference
+    /// to the newly registered [`Class`].
     pub fn register(self) -> &'static Class {
         // Forget self, otherwise the class will be disposed in drop
         let cls = ManuallyDrop::new(self).cls;
@@ -305,7 +308,7 @@ impl ClassDecl {
     }
 }
 
-impl Drop for ClassDecl {
+impl Drop for ClassBuilder {
     fn drop(&mut self) {
         unsafe { ffi::objc_disposeClassPair(self.as_ptr()) }
     }
@@ -314,20 +317,24 @@ impl Drop for ClassDecl {
 /// A type for declaring a new protocol and adding new methods to it
 /// before registering it.
 #[derive(Debug)]
-pub struct ProtocolDecl {
+pub struct ProtocolBuilder {
     proto: NonNull<Protocol>,
 }
 
-// SAFETY: Similar to ClassDecl
-unsafe impl Send for ProtocolDecl {}
-unsafe impl Sync for ProtocolDecl {}
+#[doc(hidden)]
+#[deprecated = "Use `ProtocolBuilder` instead."]
+pub type ProtocolDecl = ProtocolBuilder;
+
+// SAFETY: Similar to ClassBuilder
+unsafe impl Send for ProtocolBuilder {}
+unsafe impl Sync for ProtocolBuilder {}
 
-impl ProtocolDecl {
+impl ProtocolBuilder {
     fn as_ptr(&self) -> *mut ffi::objc_protocol {
         self.proto.as_ptr().cast()
     }
 
-    /// Constructs a [`ProtocolDecl`] with the given name.
+    /// Constructs a [`ProtocolBuilder`] with the given name.
     ///
     /// Returns [`None`] if the protocol couldn't be allocated.
     pub fn new(name: &str) -> Option<Self> {
@@ -391,7 +398,7 @@ impl ProtocolDecl {
         }
     }
 
-    /// Registers the [`ProtocolDecl`], consuming it and returning a reference
+    /// Registers the [`ProtocolBuilder`], consuming it and returning a reference
     /// to the newly registered [`Protocol`].
     pub fn register(self) -> &'static Protocol {
         unsafe {

objc2/src/test_utils.rs

@@ -2,7 +2,7 @@ use core::ops::{Deref, DerefMut};
 use std::os::raw::c_char;
 use std::sync::Once;
 
-use crate::declare::{ClassDecl, ProtocolDecl};
+use crate::declare::{ClassBuilder, ProtocolBuilder};
 use crate::runtime::{Class, Object, Protocol, Sel};
 use crate::{ffi, Encode, Encoding, MessageReceiver};
 
@@ -75,11 +75,11 @@ pub(crate) fn custom_class() -> &'static Class {
         // The runtime will call this method, so it has to be implemented
         extern "C" fn custom_obj_class_initialize(_this: &Class, _cmd: Sel) {}
 
-        let mut decl = ClassDecl::root("CustomObject", custom_obj_class_initialize).unwrap();
+        let mut builder = ClassBuilder::root("CustomObject", custom_obj_class_initialize).unwrap();
         let proto = custom_protocol();
 
-        decl.add_protocol(proto);
-        decl.add_ivar::<u32>("_foo");
+        builder.add_protocol(proto);
+        builder.add_ivar::<u32>("_foo");
 
         extern "C" fn custom_obj_set_foo(this: &mut Object, _cmd: Sel, foo: u32) {
             unsafe {
@@ -121,22 +121,22 @@ pub(crate) fn custom_class() -> &'static Class {
 
         unsafe {
             let set_foo: extern "C" fn(&mut Object, Sel, u32) = custom_obj_set_foo;
-            decl.add_method(sel!(setFoo:), set_foo);
+            builder.add_method(sel!(setFoo:), set_foo);
             let get_foo: extern "C" fn(&Object, Sel) -> u32 = custom_obj_get_foo;
-            decl.add_method(sel!(foo), get_foo);
+            builder.add_method(sel!(foo), get_foo);
             let get_struct: extern "C" fn(&Object, Sel) -> CustomStruct = custom_obj_get_struct;
-            decl.add_method(sel!(customStruct), get_struct);
+            builder.add_method(sel!(customStruct), get_struct);
             let class_method: extern "C" fn(&Class, Sel) -> u32 = custom_obj_class_method;
-            decl.add_class_method(sel!(classFoo), class_method);
+            builder.add_class_method(sel!(classFoo), class_method);
 
             let protocol_instance_method: extern "C" fn(&mut Object, Sel, u32) = custom_obj_set_bar;
-            decl.add_method(sel!(setBar:), protocol_instance_method);
+            builder.add_method(sel!(setBar:), protocol_instance_method);
             let protocol_class_method: extern "C" fn(&Class, Sel, i32, i32) -> i32 =
                 custom_obj_add_number_to_number;
-            decl.add_class_method(sel!(addNumber:toNumber:), protocol_class_method);
+            builder.add_class_method(sel!(addNumber:toNumber:), protocol_class_method);
         }
 
-        decl.register();
+        builder.register();
     });
 
     class!(CustomObject)
@@ -146,13 +146,13 @@ pub(crate) fn custom_protocol() -> &'static Protocol {
     static REGISTER_CUSTOM_PROTOCOL: Once = Once::new();
 
     REGISTER_CUSTOM_PROTOCOL.call_once(|| {
-        let mut decl = ProtocolDecl::new("CustomProtocol").unwrap();
+        let mut builder = ProtocolBuilder::new("CustomProtocol").unwrap();
 
-        decl.add_method_description::<(i32,), ()>(sel!(setBar:), true);
-        decl.add_method_description::<(), *const c_char>(sel!(getName), false);
-        decl.add_class_method_description::<(i32, i32), i32>(sel!(addNumber:toNumber:), true);
+        builder.add_method_description::<(i32,), ()>(sel!(setBar:), true);
+        builder.add_method_description::<(), *const c_char>(sel!(getName), false);
+        builder.add_class_method_description::<(i32, i32), i32>(sel!(addNumber:toNumber:), true);
 
-        decl.register();
+        builder.register();
     });
 
     Protocol::get("CustomProtocol").unwrap()
@@ -163,12 +163,12 @@ pub(crate) fn custom_subprotocol() -> &'static Protocol {
 
     REGISTER_CUSTOM_SUBPROTOCOL.call_once(|| {
         let super_proto = custom_protocol();
-        let mut decl = ProtocolDecl::new("CustomSubProtocol").unwrap();
+        let mut builder = ProtocolBuilder::new("CustomSubProtocol").unwrap();
 
-        decl.add_protocol(super_proto);
-        decl.add_method_description::<(u32,), u32>(sel!(calculateFoo:), true);
+        builder.add_protocol(super_proto);
+        builder.add_method_description::<(u32,), u32>(sel!(calculateFoo:), true);
 
-        decl.register();
+        builder.register();
     });
 
     Protocol::get("CustomSubProtocol").unwrap()
@@ -183,7 +183,7 @@ pub(crate) fn custom_subclass() -> &'static Class {
 
     REGISTER_CUSTOM_SUBCLASS.call_once(|| {
         let superclass = custom_class();
-        let mut decl = ClassDecl::new("CustomSubclassObject", superclass).unwrap();
+        let mut builder = ClassBuilder::new("CustomSubclassObject", superclass).unwrap();
 
         extern "C" fn custom_subclass_get_foo(this: &Object, _cmd: Sel) -> u32 {
             let foo: u32 = unsafe { msg_send![super(this, custom_class()), foo] };
@@ -192,10 +192,10 @@ pub(crate) fn custom_subclass() -> &'static Class {
 
         unsafe {
             let get_foo: extern "C" fn(&Object, Sel) -> u32 = custom_subclass_get_foo;
-            decl.add_method(sel!(foo), get_foo);
+            builder.add_method(sel!(foo), get_foo);
         }
 
-        decl.register();
+        builder.register();
     });
 
     class!(CustomSubclassObject)