chore: Bump Rust edition to 2024 (#27800)

Follow-up to https://github.com/zed-industries/zed/pull/27791

Release Notes:

- N/A

crates/collab/src/tests/channel_buffer_tests.rs

@@ -1,6 +1,6 @@
 use crate::{
     rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
-    tests::{test_server::open_channel_notes, TestServer},
+    tests::{TestServer, test_server::open_channel_notes},
 };
 use call::ActiveCall;
 use channel::ACKNOWLEDGE_DEBOUNCE_INTERVAL;
@@ -10,7 +10,7 @@ use collections::HashMap;
 use editor::{Anchor, Editor, ToOffset};
 use futures::future;
 use gpui::{BackgroundExecutor, Context, Entity, TestAppContext, Window};
-use rpc::{proto::PeerId, RECEIVE_TIMEOUT};
+use rpc::{RECEIVE_TIMEOUT, proto::PeerId};
 use serde_json::json;
 use std::ops::Range;
 

crates/collab/src/tests/channel_guest_tests.rs

@@ -51,13 +51,15 @@ async fn test_channel_guests(
         Some(project_id),
     );
     assert!(project_b.read_with(cx_b, |project, cx| project.is_read_only(cx)));
-    assert!(project_b
-        .update(cx_b, |project, cx| {
-            let worktree_id = project.worktrees(cx).next().unwrap().read(cx).id();
-            project.create_entry((worktree_id, "b.txt"), false, cx)
-        })
-        .await
-        .is_err());
+    assert!(
+        project_b
+            .update(cx_b, |project, cx| {
+                let worktree_id = project.worktrees(cx).next().unwrap().read(cx).id();
+                project.create_entry((worktree_id, "b.txt"), false, cx)
+            })
+            .await
+            .is_err()
+    );
     assert!(room_b.read_with(cx_b, |room, _| room.is_muted()));
 }
 
@@ -110,10 +112,12 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
     cx_b.update(|_window, cx_b| {
         assert!(room_b.read_with(cx_b, |room, _| !room.can_use_microphone()));
     });
-    assert!(room_b
-        .update(cx_b, |room, cx| room.share_microphone(cx))
-        .await
-        .is_err());
+    assert!(
+        room_b
+            .update(cx_b, |room, cx| room.share_microphone(cx))
+            .await
+            .is_err()
+    );
 
     // B is promoted
     active_call_a
@@ -161,10 +165,12 @@ async fn test_channel_guest_promotion(cx_a: &mut TestAppContext, cx_b: &mut Test
     // project and buffers are no longer editable
     assert!(project_b.read_with(cx_b, |project, cx| project.is_read_only(cx)));
     assert!(editor_b.update(cx_b, |editor, cx| editor.read_only(cx)));
-    assert!(room_b
-        .update(cx_b, |room, cx| room.share_microphone(cx))
-        .await
-        .is_err());
+    assert!(
+        room_b
+            .update(cx_b, |room, cx| room.share_microphone(cx))
+            .await
+            .is_err()
+    );
 }
 
 #[gpui::test]

crates/collab/src/tests/channel_tests.rs

@@ -1,7 +1,7 @@
 use crate::{
     db::{self, UserId},
     rpc::RECONNECT_TIMEOUT,
-    tests::{room_participants, RoomParticipants, TestServer},
+    tests::{RoomParticipants, TestServer, room_participants},
 };
 use call::ActiveCall;
 use channel::{ChannelMembership, ChannelStore};
@@ -9,8 +9,8 @@ use client::{ChannelId, User};
 use futures::future::try_join_all;
 use gpui::{BackgroundExecutor, Entity, SharedString, TestAppContext};
 use rpc::{
-    proto::{self, ChannelRole},
     RECEIVE_TIMEOUT,
+    proto::{self, ChannelRole},
 };
 use std::sync::Arc;
 
@@ -348,10 +348,12 @@ async fn test_joining_channel_ancestor_member(
 
     let active_call_b = cx_b.read(ActiveCall::global);
 
-    assert!(active_call_b
-        .update(cx_b, |active_call, cx| active_call.join_channel(sub_id, cx))
-        .await
-        .is_ok());
+    assert!(
+        active_call_b
+            .update(cx_b, |active_call, cx| active_call.join_channel(sub_id, cx))
+            .await
+            .is_ok()
+    );
 }
 
 #[gpui::test]
@@ -1203,10 +1205,12 @@ async fn test_guest_access(
     let active_call_b = cx_b.read(ActiveCall::global);
 
     // Non-members should not be allowed to join
-    assert!(active_call_b
-        .update(cx_b, |call, cx| call.join_channel(channel_a, cx))
-        .await
-        .is_err());
+    assert!(
+        active_call_b
+            .update(cx_b, |call, cx| call.join_channel(channel_a, cx))
+            .await
+            .is_err()
+    );
 
     // Make channels A and B public
     client_a
@@ -1271,10 +1275,12 @@ async fn test_invite_access(
     let active_call_b = cx_b.read(ActiveCall::global);
 
     // should not be allowed to join
-    assert!(active_call_b
-        .update(cx_b, |call, cx| call.join_channel(channel_b_id, cx))
-        .await
-        .is_err());
+    assert!(
+        active_call_b
+            .update(cx_b, |call, cx| call.join_channel(channel_b_id, cx))
+            .await
+            .is_err()
+    );
 
     client_a
         .channel_store()

crates/collab/src/tests/editor_tests.rs

@@ -1,9 +1,10 @@
 use crate::{
     rpc::RECONNECT_TIMEOUT,
-    tests::{rust_lang, TestServer},
+    tests::{TestServer, rust_lang},
 };
 use call::ActiveCall;
 use editor::{
+    Editor, RowInfo,
     actions::{
         ConfirmCodeAction, ConfirmCompletion, ConfirmRename, ContextMenuFirst,
         ExpandMacroRecursively, Redo, Rename, ToggleCodeActions, Undo,
@@ -12,23 +13,22 @@ use editor::{
         editor_test_context::{AssertionContextManager, EditorTestContext},
         expand_macro_recursively,
     },
-    Editor, RowInfo,
 };
 use fs::Fs;
 use futures::StreamExt;
 use gpui::{TestAppContext, UpdateGlobal, VisualContext, VisualTestContext};
 use indoc::indoc;
 use language::{
-    language_settings::{AllLanguageSettings, InlayHintSettings},
     FakeLspAdapter,
+    language_settings::{AllLanguageSettings, InlayHintSettings},
 };
 use project::{
+    ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT,
     lsp_store::{
         lsp_ext_command::{ExpandedMacro, LspExpandMacro},
         rust_analyzer_ext::RUST_ANALYZER_NAME,
     },
     project_settings::{InlineBlameSettings, ProjectSettings},
-    ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT,
 };
 use recent_projects::disconnected_overlay::DisconnectedOverlay;
 use rpc::RECEIVE_TIMEOUT;
@@ -38,8 +38,8 @@ use std::{
     ops::Range,
     path::{Path, PathBuf},
     sync::{
-        atomic::{self, AtomicBool, AtomicUsize},
         Arc,
+        atomic::{self, AtomicBool, AtomicUsize},
     },
 };
 use text::Point;

crates/collab/src/tests/following_tests.rs

@@ -8,8 +8,8 @@ use collab_ui::{
 };
 use editor::{Editor, ExcerptRange, MultiBuffer};
 use gpui::{
-    point, AppContext as _, BackgroundExecutor, BorrowAppContext, Entity, SharedString,
-    TestAppContext, VisualTestContext,
+    AppContext as _, BackgroundExecutor, BorrowAppContext, Entity, SharedString, TestAppContext,
+    VisualTestContext, point,
 };
 use language::Capability;
 use project::WorktreeSettings;
@@ -17,7 +17,7 @@ use rpc::proto::PeerId;
 use serde_json::json;
 use settings::SettingsStore;
 use util::path;
-use workspace::{item::ItemHandle as _, SplitDirection, Workspace};
+use workspace::{SplitDirection, Workspace, item::ItemHandle as _};
 
 use super::TestClient;
 
@@ -441,7 +441,7 @@ async fn test_basic_following(
         use crate::rpc::RECONNECT_TIMEOUT;
         use gpui::TestScreenCaptureSource;
         use workspace::{
-            dock::{test::TestPanel, DockPosition},
+            dock::{DockPosition, test::TestPanel},
             item::test::TestItem,
             shared_screen::SharedScreen,
         };

crates/collab/src/tests/integration_tests.rs

@@ -1,38 +1,39 @@
 use crate::{
     rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
     tests::{
-        channel_id, following_tests::join_channel, room_participants, rust_lang, RoomParticipants,
-        TestClient, TestServer,
+        RoomParticipants, TestClient, TestServer, channel_id, following_tests::join_channel,
+        room_participants, rust_lang,
     },
 };
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use assistant_context_editor::ContextStore;
 use assistant_slash_command::SlashCommandWorkingSet;
-use buffer_diff::{assert_hunks, DiffHunkSecondaryStatus, DiffHunkStatus};
-use call::{room, ActiveCall, ParticipantLocation, Room};
-use client::{User, RECEIVE_TIMEOUT};
+use buffer_diff::{DiffHunkSecondaryStatus, DiffHunkStatus, assert_hunks};
+use call::{ActiveCall, ParticipantLocation, Room, room};
+use client::{RECEIVE_TIMEOUT, User};
 use collections::{HashMap, HashSet};
 use fs::{FakeFs, Fs as _, RemoveOptions};
-use futures::{channel::mpsc, StreamExt as _};
+use futures::{StreamExt as _, channel::mpsc};
 use git::status::{FileStatus, StatusCode, TrackedStatus, UnmergedStatus, UnmergedStatusCode};
 use gpui::{
-    px, size, App, BackgroundExecutor, Entity, Modifiers, MouseButton, MouseDownEvent,
-    TestAppContext, UpdateGlobal,
+    App, BackgroundExecutor, Entity, Modifiers, MouseButton, MouseDownEvent, TestAppContext,
+    UpdateGlobal, px, size,
 };
 use language::{
+    Diagnostic, DiagnosticEntry, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher,
+    LineEnding, OffsetRangeExt, Point, Rope,
     language_settings::{
         AllLanguageSettings, Formatter, FormatterList, PrettierSettings, SelectedFormatter,
     },
-    tree_sitter_rust, tree_sitter_typescript, Diagnostic, DiagnosticEntry, FakeLspAdapter,
-    Language, LanguageConfig, LanguageMatcher, LineEnding, OffsetRangeExt, Point, Rope,
+    tree_sitter_rust, tree_sitter_typescript,
 };
 use lsp::{LanguageServerId, OneOf};
 use parking_lot::Mutex;
 use pretty_assertions::assert_eq;
 use project::{
+    DiagnosticSummary, HoverBlockKind, Project, ProjectPath,
     lsp_store::{FormatTrigger, LspFormatTarget},
     search::{SearchQuery, SearchResult},
-    DiagnosticSummary, HoverBlockKind, Project, ProjectPath,
 };
 use prompt_store::PromptBuilder;
 use rand::prelude::*;
@@ -44,8 +45,8 @@ use std::{
     path::{Path, PathBuf},
     rc::Rc,
     sync::{
-        atomic::{AtomicBool, Ordering::SeqCst},
         Arc,
+        atomic::{AtomicBool, Ordering::SeqCst},
     },
     time::Duration,
 };
@@ -6206,15 +6207,19 @@ async fn test_contact_requests(
     executor.run_until_parked();
     assert_eq!(client_a.summarize_contacts(cx_a).current, &["user_b"]);
     assert_eq!(client_b.summarize_contacts(cx_b).current, &["user_a"]);
-    assert!(client_b
-        .summarize_contacts(cx_b)
-        .incoming_requests
-        .is_empty());
+    assert!(
+        client_b
+            .summarize_contacts(cx_b)
+            .incoming_requests
+            .is_empty()
+    );
     assert!(client_c.summarize_contacts(cx_c).current.is_empty());
-    assert!(client_c
-        .summarize_contacts(cx_c)
-        .outgoing_requests
-        .is_empty());
+    assert!(
+        client_c
+            .summarize_contacts(cx_c)
+            .outgoing_requests
+            .is_empty()
+    );
 
     async fn disconnect_and_reconnect(client: &TestClient, cx: &mut TestAppContext) {
         client.disconnect(&cx.to_async());

crates/collab/src/tests/notification_tests.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use gpui::{BackgroundExecutor, TestAppContext};
 use notifications::NotificationEvent;
 use parking_lot::Mutex;
-use rpc::{proto, Notification};
+use rpc::{Notification, proto};
 
 use crate::tests::TestServer;
 

crates/collab/src/tests/random_channel_buffer_tests.rs

@@ -1,6 +1,6 @@
 use crate::db::ChannelRole;
 
-use super::{run_randomized_test, RandomizedTest, TestClient, TestError, TestServer, UserTestPlan};
+use super::{RandomizedTest, TestClient, TestError, TestServer, UserTestPlan, run_randomized_test};
 use anyhow::Result;
 use async_trait::async_trait;
 use gpui::{BackgroundExecutor, SharedString, TestAppContext};

crates/collab/src/tests/random_project_collaboration_tests.rs

@@ -1,6 +1,6 @@
 use super::{RandomizedTest, TestClient, TestError, TestServer, UserTestPlan};
 use crate::{db::UserId, tests::run_randomized_test};
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use async_trait::async_trait;
 use call::ActiveCall;
 use collections::{BTreeMap, HashMap};
@@ -9,12 +9,12 @@ use fs::{FakeFs, Fs as _};
 use git::status::{FileStatus, StatusCode, TrackedStatus, UnmergedStatus, UnmergedStatusCode};
 use gpui::{BackgroundExecutor, Entity, TestAppContext};
 use language::{
-    range_to_lsp, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, PointUtf16,
+    FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, PointUtf16, range_to_lsp,
 };
 use lsp::FakeLanguageServer;
 use pretty_assertions::assert_eq;
 use project::{
-    search::SearchQuery, search::SearchResult, Project, ProjectPath, DEFAULT_COMPLETION_CONTEXT,
+    DEFAULT_COMPLETION_CONTEXT, Project, ProjectPath, search::SearchQuery, search::SearchResult,
 };
 use rand::{
     distributions::{Alphanumeric, DistString},
@@ -27,7 +27,7 @@ use std::{
     rc::Rc,
     sync::Arc,
 };
-use util::{path, ResultExt};
+use util::{ResultExt, path};
 
 #[gpui::test(
     iterations = 100,
@@ -784,10 +784,12 @@ impl RandomizedTest for ProjectCollaborationTest {
                 let save = cx.spawn(|cx| async move {
                     save.await
                         .map_err(|err| anyhow!("save request failed: {:?}", err))?;
-                    assert!(buffer
-                        .read_with(&cx, |buffer, _| { buffer.saved_version().to_owned() })
-                        .expect("App should not be dropped")
-                        .observed_all(&requested_version));
+                    assert!(
+                        buffer
+                            .read_with(&cx, |buffer, _| { buffer.saved_version().to_owned() })
+                            .expect("App should not be dropped")
+                            .observed_all(&requested_version)
+                    );
                     anyhow::Ok(())
                 });
                 if detach {

crates/collab/src/tests/randomized_test_helpers.rs

@@ -9,7 +9,7 @@ use gpui::{BackgroundExecutor, Task, TestAppContext};
 use parking_lot::Mutex;
 use rand::prelude::*;
 use rpc::RECEIVE_TIMEOUT;
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use settings::SettingsStore;
 use std::sync::OnceLock;
 use std::{
@@ -17,8 +17,8 @@ use std::{
     path::PathBuf,
     rc::Rc,
     sync::{
-        atomic::{AtomicBool, Ordering::SeqCst},
         Arc,
+        atomic::{AtomicBool, Ordering::SeqCst},
     },
 };
 

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -10,17 +10,17 @@ use gpui::{
 };
 use http_client::BlockedHttpClient;
 use language::{
+    FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageRegistry,
     language_settings::{
-        language_settings, AllLanguageSettings, Formatter, FormatterList, PrettierSettings,
-        SelectedFormatter,
+        AllLanguageSettings, Formatter, FormatterList, PrettierSettings, SelectedFormatter,
+        language_settings,
     },
-    tree_sitter_typescript, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher,
-    LanguageRegistry,
+    tree_sitter_typescript,
 };
 use node_runtime::NodeRuntime;
 use project::{
-    lsp_store::{FormatTrigger, LspFormatTarget},
     ProjectPath,
+    lsp_store::{FormatTrigger, LspFormatTarget},
 };
 use remote::SshRemoteClient;
 use remote_server::{HeadlessAppState, HeadlessProject};

crates/collab/src/tests/test_server.rs

@@ -1,22 +1,22 @@
 use crate::{
-    db::{tests::TestDb, NewUserParams, UserId},
-    executor::Executor,
-    rpc::{Principal, Server, ZedVersion, CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
     AppState, Config, RateLimiter,
+    db::{NewUserParams, UserId, tests::TestDb},
+    executor::Executor,
+    rpc::{CLEANUP_TIMEOUT, Principal, RECONNECT_TIMEOUT, Server, ZedVersion},
 };
 use anyhow::anyhow;
 use call::ActiveCall;
 use channel::{ChannelBuffer, ChannelStore};
 use client::{
-    self, proto::PeerId, ChannelId, Client, Connection, Credentials, EstablishConnectionError,
-    UserStore,
+    self, ChannelId, Client, Connection, Credentials, EstablishConnectionError, UserStore,
+    proto::PeerId,
 };
 use clock::FakeSystemClock;
 use collab_ui::channel_view::ChannelView;
 use collections::{HashMap, HashSet};
 use dap::DapRegistry;
 use fs::FakeFs;
-use futures::{channel::oneshot, StreamExt as _};
+use futures::{StreamExt as _, channel::oneshot};
 use git::GitHostingProviderRegistry;
 use gpui::{AppContext as _, BackgroundExecutor, Entity, Task, TestAppContext, VisualTestContext};
 use http_client::FakeHttpClient;
@@ -27,8 +27,8 @@ use parking_lot::Mutex;
 use project::{Project, WorktreeId};
 use remote::SshRemoteClient;
 use rpc::{
-    proto::{self, ChannelRole},
     RECEIVE_TIMEOUT,
+    proto::{self, ChannelRole},
 };
 use semantic_version::SemanticVersion;
 use serde_json::json;
@@ -40,8 +40,8 @@ use std::{
     ops::{Deref, DerefMut},
     path::Path,
     sync::{
-        atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
         Arc,
+        atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
     },
 };
 use util::path;