chore(rustfmt): use nightly (#2325)

Stable rustfmt lacks a lot of features resulting in worse formatted
code, thus use nightly formatter.

src/platform_impl/macos/event_handler.rs

@@ -1,6 +1,5 @@
 use std::cell::RefCell;
-use std::fmt;
-use std::mem;
+use std::{fmt, mem};
 
 use super::app_delegate::HandlePendingUserEvents;
 use crate::event::Event;
@@ -53,13 +52,13 @@ impl EventHandler {
         match self.inner.try_borrow_mut().as_deref_mut() {
             Ok(Some(_)) => {
                 unreachable!("tried to set handler while another was already set");
-            }
+            },
             Ok(data @ None) => {
                 *data = Some(EventHandlerData { handler });
-            }
+            },
             Err(_) => {
                 unreachable!("tried to set handler that is currently in use");
-            }
+            },
         }
 
         struct ClearOnDrop<'a>(&'a EventHandler);
@@ -69,10 +68,10 @@ impl EventHandler {
                 match self.0.inner.try_borrow_mut().as_deref_mut() {
                     Ok(data @ Some(_)) => {
                         *data = None;
-                    }
+                    },
                     Ok(None) => {
                         tracing::error!("tried to clear handler, but no handler was set");
-                    }
+                    },
                     Err(_) => {
                         // Note: This is not expected to ever happen, this
                         // module generally controls the `RefCell`, and
@@ -83,7 +82,7 @@ impl EventHandler {
                         // weren't able to unset the handler.
                         eprintln!("tried to clear handler that is currently in use");
                         std::process::abort();
-                    }
+                    },
                 }
             }
         }
@@ -120,17 +119,17 @@ impl EventHandler {
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
                 (handler)(event, event_loop);
-            }
+            },
             Ok(None) => {
                 // `NSApplication`, our app delegate and this handler are all
                 // global state and so it's not impossible that we could get
                 // an event after the application has exited the `EventLoop`.
                 tracing::error!("tried to run event handler, but no handler was set");
-            }
+            },
             Err(_) => {
                 // Prevent re-entrancy.
                 panic!("tried to handle event while another event is currently being handled");
-            }
+            },
         }
     }
 }