Update macOS build configuration

Author: Choochmeque

.cargo/config.toml

@@ -1,2 +1,12 @@
 [env]
 MACOSX_DEPLOYMENT_TARGET = "13.0"
+
+[target.'cfg(all())']
+rustflags = [
+    "-Wclippy::all",
+    "-Wclippy::pedantic",
+    "-Wclippy::nursery",
+    "-Wclippy::unwrap_used",
+    "-Aclippy::module_name_repetitions",
+    "-Aclippy::missing_errors_doc",
+]

build.rs

@@ -34,7 +34,7 @@ fn main() {
         .unwrap_or_default()
         .contains("android")
     {
-        let properties_content = format!("enablePushNotifications={}", enable_push);
+        let properties_content = format!("enablePushNotifications={enable_push}");
         std::fs::write("android/build.properties", properties_content)
             .expect("Failed to write build.properties");
     }
@@ -73,6 +73,10 @@ fn main() {
     {
         // Only run macOS-specific build steps when building for macOS
         if std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default() == "macos" {
+            // Rebuild when target architecture or deployment target changes
+            println!("cargo:rerun-if-env-changed=CARGO_CFG_TARGET_ARCH");
+            println!("cargo:rerun-if-env-changed=MACOSX_DEPLOYMENT_TARGET");
+
             let bridges = vec!["src/macos.rs"];
             for path in &bridges {
                 println!("cargo:rerun-if-changed={path}");
@@ -99,18 +103,22 @@ fn main() {
 #[cfg(target_os = "macos")]
 fn compile_swift() {
     let swift_package_dir = manifest_dir().join("macos");
+    let target_triple = swift_target_triple();
 
     let mut cmd = Command::new("swift");
 
-    cmd.current_dir(swift_package_dir).arg("build").args([
-        "-Xswiftc",
-        "-import-objc-header",
-        "-Xswiftc",
-        swift_source_dir()
-            .join("bridging-header.h")
-            .to_str()
-            .expect("Bridging header path must be valid UTF-8"),
-    ]);
+    cmd.current_dir(&swift_package_dir)
+        .arg("build")
+        .args(["--triple", &target_triple])
+        .args([
+            "-Xswiftc",
+            "-import-objc-header",
+            "-Xswiftc",
+            swift_source_dir()
+                .join("bridging-header.h")
+                .to_str()
+                .expect("Bridging header path must be valid UTF-8"),
+        ]);
 
     if is_release_build() {
         cmd.args(["-c", "release"]);
@@ -122,16 +130,17 @@ fn compile_swift() {
         .wait_with_output()
         .expect("Failed to wait for swift build output");
 
-    if !exit_status.status.success() {
-        panic!(
-            r#"
+    assert!(
+        exit_status.status.success(),
+        r"
+Swift build failed for target: {}
 Stderr: {}
 Stdout: {}
-"#,
-            String::from_utf8(exit_status.stderr).expect("Stderr must be valid UTF-8"),
-            String::from_utf8(exit_status.stdout).expect("Stdout must be valid UTF-8"),
-        )
-    }
+",
+        target_triple,
+        String::from_utf8(exit_status.stderr).expect("Stderr must be valid UTF-8"),
+        String::from_utf8(exit_status.stdout).expect("Stdout must be valid UTF-8"),
+    );
 }
 
 #[cfg(target_os = "macos")]
@@ -160,6 +169,30 @@ fn generated_code_dir() -> PathBuf {
     swift_source_dir().join("generated")
 }
 
+#[cfg(target_os = "macos")]
+fn target_arch() -> String {
+    std::env::var("CARGO_CFG_TARGET_ARCH").expect("CARGO_CFG_TARGET_ARCH must be set")
+}
+
+#[cfg(target_os = "macos")]
+fn swift_arch() -> &'static str {
+    match target_arch().as_str() {
+        "aarch64" => "arm64",
+        "x86_64" => "x86_64",
+        arch => panic!("Unsupported architecture for macOS: {arch}"),
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn macos_deployment_target() -> String {
+    std::env::var("MACOSX_DEPLOYMENT_TARGET").unwrap_or_else(|_| "13.0".to_string())
+}
+
+#[cfg(target_os = "macos")]
+fn swift_target_triple() -> String {
+    format!("{}-apple-macosx{}", swift_arch(), macos_deployment_target())
+}
+
 #[cfg(target_os = "macos")]
 fn swift_library_static_lib_dir() -> PathBuf {
     let debug_or_release = if is_release_build() {
@@ -168,5 +201,6 @@ fn swift_library_static_lib_dir() -> PathBuf {
         "debug"
     };
 
-    manifest_dir().join(format!("macos/.build/{debug_or_release}"))
+    let arch_dir = format!("{}-apple-macosx", swift_arch());
+    manifest_dir().join(format!("macos/.build/{arch_dir}/{debug_or_release}"))
 }

src/commands.rs

@@ -1,18 +1,22 @@
+// Tauri command handlers must take owned values: `State<'_, _>` is the framework's
+// preferred wrapper, and serde-deserialized payloads (Vec, String, ...) cannot be borrowed.
+#![allow(clippy::needless_pass_by_value)]
+
 use serde::Deserialize;
 use tauri::{command, plugin::PermissionState, AppHandle, Runtime, State};
 
 use crate::{NotificationData, Notifications, Result};
 
 #[derive(Debug, Deserialize)]
 #[allow(dead_code)]
-pub(crate) struct NotificationIdentifier {
+pub struct NotificationIdentifier {
     pub id: i32,
     #[allow(dead_code)]
     pub tag: Option<String>,
 }
 
 #[command]
-pub(crate) async fn is_permission_granted<R: Runtime>(
+pub async fn is_permission_granted<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<Option<bool>> {
@@ -25,31 +29,31 @@ pub(crate) async fn is_permission_granted<R: Runtime>(
 }
 
 #[command]
-pub(crate) async fn request_permission<R: Runtime>(
+pub async fn request_permission<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<PermissionState> {
     notification.request_permission().await
 }
 
 #[command]
-pub(crate) async fn register_for_push_notifications<R: Runtime>(
+pub async fn register_for_push_notifications<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<String> {
     notification.register_for_push_notifications().await
 }
 
 #[command]
-pub(crate) async fn unregister_for_push_notifications<R: Runtime>(
+pub async fn unregister_for_push_notifications<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<()> {
     notification.unregister_for_push_notifications()
 }
 
 #[command]
-pub(crate) async fn notify<R: Runtime>(
+pub async fn notify<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     options: NotificationData,
@@ -60,7 +64,7 @@ pub(crate) async fn notify<R: Runtime>(
 }
 
 #[command]
-pub(crate) async fn register_action_types<R: Runtime>(
+pub async fn register_action_types<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     types: Vec<crate::ActionType>,
@@ -69,23 +73,23 @@ pub(crate) async fn register_action_types<R: Runtime>(
 }
 
 #[command]
-pub(crate) async fn get_pending<R: Runtime>(
+pub async fn get_pending<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<Vec<crate::PendingNotification>> {
     notification.pending().await
 }
 
 #[command]
-pub(crate) async fn get_active<R: Runtime>(
+pub async fn get_active<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<Vec<crate::ActiveNotification>> {
     notification.active().await
 }
 
 #[command]
-pub(crate) fn set_click_listener_active<R: Runtime>(
+pub fn set_click_listener_active<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     active: bool,
@@ -94,7 +98,7 @@ pub(crate) fn set_click_listener_active<R: Runtime>(
 }
 
 #[command]
-pub(crate) fn remove_active<R: Runtime>(
+pub fn remove_active<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     notifications: Vec<NotificationIdentifier>,
@@ -104,7 +108,7 @@ pub(crate) fn remove_active<R: Runtime>(
 }
 
 #[command]
-pub(crate) fn cancel<R: Runtime>(
+pub fn cancel<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     notifications: Vec<i32>,
@@ -113,15 +117,15 @@ pub(crate) fn cancel<R: Runtime>(
 }
 
 #[command]
-pub(crate) fn cancel_all<R: Runtime>(
+pub fn cancel_all<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<()> {
     notification.cancel_all()
 }
 
 #[command]
-pub(crate) fn create_channel<R: Runtime>(
+pub fn create_channel<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     channel: crate::Channel,
@@ -130,7 +134,7 @@ pub(crate) fn create_channel<R: Runtime>(
 }
 
 #[command]
-pub(crate) fn delete_channel<R: Runtime>(
+pub fn delete_channel<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
     id: String,
@@ -139,7 +143,7 @@ pub(crate) fn delete_channel<R: Runtime>(
 }
 
 #[command]
-pub(crate) fn list_channels<R: Runtime>(
+pub fn list_channels<R: Runtime>(
     _app: AppHandle<R>,
     notification: State<'_, Notifications<R>>,
 ) -> Result<Vec<crate::Channel>> {

src/desktop.rs

@@ -6,6 +6,8 @@ use tauri::{
 
 use crate::NotificationsBuilder;
 
+// Signature must match the iOS/Android `init` so the cfg-gated call sites in `lib.rs::init` compile uniformly.
+#[allow(clippy::unnecessary_wraps)]
 pub fn init<R: Runtime, C: DeserializeOwned>(
     app: &AppHandle<R>,
     _api: PluginApi<R, C>,
@@ -18,6 +20,8 @@ pub fn init<R: Runtime, C: DeserializeOwned>(
 /// You can get an instance of this type via [`NotificationsExt`](crate::NotificationsExt)
 pub struct Notifications<R: Runtime>(AppHandle<R>);
 
+// `async` and `Result` mirror the mobile/macOS plugin API so callers can `.await` and `?` uniformly.
+#[allow(clippy::unused_async, clippy::unnecessary_wraps)]
 impl<R: Runtime> crate::NotificationsBuilder<R> {
     pub async fn show(self) -> crate::Result<()> {
         let mut notification = imp::Notification::new(self.app.config().identifier.clone());
@@ -42,6 +46,8 @@ impl<R: Runtime> crate::NotificationsBuilder<R> {
     }
 }
 
+// `async` mirrors the mobile/macOS plugin API so callers can `.await` uniformly.
+#[allow(clippy::unused_async)]
 impl<R: Runtime> Notifications<R> {
     pub fn builder(&self) -> NotificationsBuilder<R> {
         NotificationsBuilder::new(self.0.clone())
@@ -181,6 +187,8 @@ mod imp {
         }
 
         /// Shows the notification.
+        // `current_exe()?` returns Result on Windows; Result is kept for that branch.
+        #[allow(clippy::unnecessary_wraps)]
         pub fn show(self) -> crate::Result<()> {
             let mut notification = notify_rust::Notification::new();
             if let Some(body) = self.body {

src/error.rs

@@ -2,7 +2,7 @@ use serde::{ser::Serializer, Serialize};
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-/// Replica of the tauri::plugin::mobile::ErrorResponse for desktop platforms.
+/// Replica of the [`tauri::plugin::mobile::ErrorResponse`] for desktop platforms.
 #[cfg(desktop)]
 #[derive(Debug, thiserror::Error, Clone, serde::Deserialize)]
 pub struct ErrorResponse<T = ()> {
@@ -31,7 +31,7 @@ impl<T> std::fmt::Display for ErrorResponse<T> {
     }
 }
 
-/// Replica of the tauri::plugin::mobile::PluginInvokeError for desktop platforms.
+/// Replica of the [`tauri::plugin::mobile::PluginInvokeError`] for desktop platforms.
 #[cfg(desktop)]
 #[derive(Debug, thiserror::Error)]
 pub enum PluginInvokeError {
@@ -91,7 +91,7 @@ mod tests {
     fn test_io_error_display() {
         let io_err = io::Error::new(io::ErrorKind::NotFound, "test error");
         let err = Error::Io(io_err);
-        let display_str = format!("{}", err);
+        let display_str = format!("{err}");
         assert!(display_str.contains("test error"));
     }