Migrate warp_core + warpui_extras macOS code to objc2 (#11668)

## Description
Migrates the macOS code in `warp_core` and `warpui_extras` from the
deprecated `objc`/`cocoa` crates to `objc2`/`objc2-foundation`.

- **`warp_core`**: `channel/state.rs` bundle-identifier lookup now uses
the typed `objc2_foundation::NSBundle` API instead of `msg_send!`
(`macos.rs`/`paths.rs` were already on objc2). Drops the now-unused
`cocoa`/`objc` deps.
- **`warpui_extras`**: `user_preferences/user_defaults.rs` now uses
`Retained<NSUserDefaults>` with the typed `NSUserDefaults` API
(replacing `StrongPtr` + `msg_send!`); the `user_preferences` feature
swaps `cocoa`/`objc` for `objc2`/`objc2-foundation`.

Part of the macOS `objc` → `objc2` migration; the primary goal is memory
safety. This is binding-layer-only with **no logical changes**:
read/write/remove semantics, bundle-id handling, and ownership are
preserved exactly (objc2 `Retained` Drop replaces the manual `StrongPtr`
release 1:1). The `.expect()` on `initWithSuiteName:` is documented and
provably unreachable for the real `{app_id}-{profile}` suite-name
format.

## Testing
- `cargo check`, `cargo clippy --all-targets -- -D warnings`, and `cargo
nextest run` for `warp_core` + `warpui_extras` pass (43 tests; after
merging latest `master`).
- An independent reviewer audited the diff for no-logical-change
(NSUserDefaults ownership mapping, None/empty handling, and the
`.expect()` unreachability proof) — clean.

- [x] Warp Agent Mode — created via Warp's AI Agent Mode.

<!--
CHANGELOG-NONE
-->

Co-Authored-By: Oz <oz-agent@warp.dev>

---------

Co-authored-by: Oz <oz-agent@warp.dev>

Author: vorporeal

Cargo.lock

@@ -64,8 +64,6 @@ chrono.workspace = true
 tokio.workspace = true
 
 [target.'cfg(target_os = "macos")'.dependencies]
-cocoa.workspace = true
-objc.workspace = true
 objc2-foundation = { workspace = true, features = [
     "NSString",
     "NSURL",

crates/warp_core/Cargo.toml

@@ -421,26 +421,17 @@ fn app_id_from_bundle() -> Option<AppId> {
     // We skip this for tests, as the call to `mainBundle` can take 30+ms,
     // which is a significant portion of the total test runtime.
     #[cfg(all(target_os = "macos", not(feature = "test-util")))]
-    #[allow(deprecated)]
-    unsafe {
-        use cocoa::base::{id, nil};
-        use cocoa::foundation::NSBundle;
-        use objc::{msg_send, sel, sel_impl};
-        use warpui::platform::mac::utils::nsstring_as_str;
-
-        let bundle = id::mainBundle();
-        if bundle != nil {
-            let nsstring: id = msg_send![bundle, bundleIdentifier];
-            if nsstring != nil {
-                let app_id = nsstring_as_str(nsstring)
-                    .expect("bundle IDs should always be valid UTF-8 strings");
-
-                if !app_id.is_empty() {
-                    return Some(
-                        AppId::parse(app_id)
-                            .expect("macOS bundle identifier has an unexpected format"),
-                    );
-                }
+    {
+        use objc2_foundation::NSBundle;
+
+        let bundle = NSBundle::mainBundle();
+        if let Some(bundle_identifier) = bundle.bundleIdentifier() {
+            let app_id = bundle_identifier.to_string();
+            if !app_id.is_empty() {
+                return Some(
+                    AppId::parse(&app_id)
+                        .expect("macOS bundle identifier has an unexpected format"),
+                );
             }
         }
     }

crates/warp_core/src/channel/state.rs

@@ -10,7 +10,7 @@ license.workspace = true
 default = ["secure_storage", "user_preferences", "user_preferences-file"]
 secure_storage = ["dep:security-framework", "dep:secret-service", "dep:ouroboros"]
 test-util = []
-user_preferences = ["dep:cocoa", "dep:objc", "dep:gloo-storage"]
+user_preferences = ["dep:objc2", "dep:objc2-foundation", "dep:gloo-storage"]
 user_preferences-file = ["user_preferences", "dep:serde", "dep:serde_json"]
 user_preferences-toml = ["user_preferences", "dep:serde", "dep:serde_json", "dep:toml_edit"]
 
@@ -31,8 +31,11 @@ warpui_extras = { path = ".", features = ["test-util"] }
 tempfile.workspace = true
 
 [target.'cfg(target_os = "macos")'.dependencies]
-cocoa = { workspace = true, optional = true }
-objc = { workspace = true, optional = true }
+objc2 = { workspace = true, optional = true }
+objc2-foundation = { workspace = true, optional = true, features = [
+    "NSString",
+    "NSUserDefaults",
+] }
 security-framework = { version = "2.0.0", optional = true }
 
 [target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]

crates/warpui_extras/Cargo.toml

@@ -1,15 +1,14 @@
 //! Implementation of the [`UserPreferences`] trait using macOS user defaults.
 
-#![allow(deprecated)]
-
-use cocoa::base::{id, nil};
-use objc::rc::StrongPtr;
-use objc::{class, msg_send, sel, sel_impl};
+use objc2::rc::Retained;
+use objc2::runtime::AnyObject;
+use objc2::AnyThread;
+use objc2_foundation::{NSString, NSUserDefaults};
 
 /// A user preferences store backed by macOS user defaults (`NSUserDefaults`).
 pub struct UserDefaultsPreferencesStorage {
     /// A strong reference to the `NSUserDefaults` backing store.
-    user_defaults: StrongPtr,
+    user_defaults: Retained<NSUserDefaults>,
 }
 
 impl UserDefaultsPreferencesStorage {
@@ -29,74 +28,53 @@ impl UserDefaultsPreferencesStorage {
     ///
     /// If [`None`] is provided as the suite name, the standard user defaults
     /// will be used (namespaced based on the current application).
-    fn user_defaults(suite_name: Option<String>) -> StrongPtr {
-        unsafe {
-            // Calling `[[NSUserDefaults alloc] initWithSuiteName]`` where the suite name is the
-            // application's bundle ID (the default `data_domain` if `data_profile` is unset)
-            // _should_ be equivalent to `[NSUserDefaults standardUserDefaults]`. However, in case
-            // the two ever deviate, we explicitly use `standardUserDefaults` below. The Apple docs
-            // also imply that `standardUserDefaults` is cached.
-            if let Some(suite_name) = &suite_name {
-                let defaults: id = msg_send![class!(NSUserDefaults), alloc];
-                let suite_name = util::make_nsstring(suite_name);
+    fn user_defaults(suite_name: Option<String>) -> Retained<NSUserDefaults> {
+        // Calling `[[NSUserDefaults alloc] initWithSuiteName]`` where the suite name is the
+        // application's bundle ID (the default `data_domain` if `data_profile` is unset)
+        // _should_ be equivalent to `[NSUserDefaults standardUserDefaults]`. However, in case
+        // the two ever deviate, we explicitly use `standardUserDefaults` below. The Apple docs
+        // also imply that `standardUserDefaults` is cached.
+        if let Some(suite_name) = &suite_name {
+            let suite_name = NSString::from_str(suite_name);
 
-                StrongPtr::new(msg_send![defaults, initWithSuiteName: *suite_name])
-            } else {
-                StrongPtr::retain(msg_send![class!(NSUserDefaults), standardUserDefaults])
-            }
+            // `initWithSuiteName:` only returns nil when the suite name is a reserved domain
+            // (NSGlobalDomain/NSArgumentDomain/NSRegistrationDomain) or the app's own bundle
+            // identifier; our `{app_id}-{profile}` suite name is never either of those, so this
+            // is unreachable in practice.
+            NSUserDefaults::initWithSuiteName(NSUserDefaults::alloc(), Some(&suite_name)).expect(
+                "initWithSuiteName: only returns nil for a reserved domain or the app's own bundle id",
+            )
+        } else {
+            NSUserDefaults::standardUserDefaults()
         }
     }
 }
 
 impl super::UserPreferences for UserDefaultsPreferencesStorage {
     fn write_value(&self, key: &str, value: String) -> Result<(), super::Error> {
-        unsafe {
-            let key = util::make_nsstring(key);
-            let value = util::make_nsstring(&value);
+        let key = NSString::from_str(key);
+        let value = NSString::from_str(&value);
+        let value: &AnyObject = &value;
 
-            let _: () = msg_send![*self.user_defaults, setObject: *value forKey: *key];
-            Ok(())
+        // `setObject:forKey:` stores an arbitrary object; the value and key are
+        // both `NSString`s, which are valid property-list types.
+        unsafe {
+            self.user_defaults.setObject_forKey(Some(value), &key);
         }
+        Ok(())
     }
 
     fn read_value(&self, key: &str) -> Result<Option<String>, super::Error> {
-        unsafe {
-            let key = util::make_nsstring(key);
-            let value: id = msg_send![*self.user_defaults, stringForKey: *key];
-            if value != nil {
-                Ok(Some(
-                    warpui::platform::mac::utils::nsstring_as_str(value)?.to_owned(),
-                ))
-            } else {
-                Ok(None)
-            }
+        let key = NSString::from_str(key);
+        match self.user_defaults.stringForKey(&key) {
+            Some(value) => Ok(Some(value.to_string())),
+            None => Ok(None),
         }
     }
 
     fn remove_value(&self, key: &str) -> Result<(), super::Error> {
-        unsafe {
-            let key = util::make_nsstring(key);
-            let _: () = msg_send![*self.user_defaults, removeObjectForKey: *key];
-            Ok(())
-        }
-    }
-}
-
-mod util {
-    use cocoa::base::nil;
-    use cocoa::foundation::NSString;
-    use objc::rc::StrongPtr;
-
-    /// Creates a new `NSString` from the given `&str`, wrapped in a
-    /// [`StrongPtr`] so it is released when the `StrongPtr` is dropped.
-    ///
-    /// **Important:** when passing the result to `msg_send!`, always
-    /// dereference it (e.g. `msg_send![obj, foo: *nsstring]`). Passing the
-    /// `StrongPtr` itself by value causes it to be moved into the
-    /// `unsafe extern fn` call that `msg_send!` transmutes to, and Rust will
-    /// not run the `StrongPtr`'s `Drop` glue after that call, leaking the
-    /// underlying `NSString`.
-    pub fn make_nsstring(value: &str) -> StrongPtr {
-        unsafe { StrongPtr::new(NSString::alloc(nil).init_str(value)) }
+        let key = NSString::from_str(key);
+        self.user_defaults.removeObjectForKey(&key);
+        Ok(())
     }
 }