lints: A bunch of extra style lint fixes (#36568)

- **lints: Fix 'doc_lazy_continuation'**
- **lints: Fix 'doc_overindented_list_items'**
- **inherent_to_string and io_other_error**
- **Some more lint fixes**
- **lints: enable bool_assert_comparison, match_like_matches_macro and
wrong_self_convention**


Release Notes:

- N/A

crates/gpui/src/action.rs

@@ -73,18 +73,18 @@ macro_rules! actions {
 /// - `name = "ActionName"` overrides the action's name. This must not contain `::`.
 ///
 /// - `no_json` causes the `build` method to always error and `action_json_schema` to return `None`,
-/// and allows actions not implement `serde::Serialize` and `schemars::JsonSchema`.
+///   and allows actions not implement `serde::Serialize` and `schemars::JsonSchema`.
 ///
 /// - `no_register` skips registering the action. This is useful for implementing the `Action` trait
-/// while not supporting invocation by name or JSON deserialization.
+///   while not supporting invocation by name or JSON deserialization.
 ///
 /// - `deprecated_aliases = ["editor::SomeAction"]` specifies deprecated old names for the action.
-/// These action names should *not* correspond to any actions that are registered. These old names
-/// can then still be used to refer to invoke this action. In Zed, the keymap JSON schema will
-/// accept these old names and provide warnings.
+///   These action names should *not* correspond to any actions that are registered. These old names
+///   can then still be used to refer to invoke this action. In Zed, the keymap JSON schema will
+///   accept these old names and provide warnings.
 ///
 /// - `deprecated = "Message about why this action is deprecation"` specifies a deprecation message.
-/// In Zed, the keymap JSON schema will cause this to be displayed as a warning.
+///   In Zed, the keymap JSON schema will cause this to be displayed as a warning.
 ///
 /// # Manual Implementation
 ///

crates/gpui/src/app/test_context.rs

@@ -192,6 +192,7 @@ impl TestAppContext {
         &self.foreground_executor
     }
 
+    #[expect(clippy::wrong_self_convention)]
     fn new<T: 'static>(&mut self, build_entity: impl FnOnce(&mut Context<T>) -> T) -> Entity<T> {
         let mut cx = self.app.borrow_mut();
         cx.new(build_entity)
@@ -244,7 +245,7 @@ impl TestAppContext {
             )
             .unwrap();
         drop(cx);
-        let cx = VisualTestContext::from_window(*window.deref(), self).as_mut();
+        let cx = VisualTestContext::from_window(*window.deref(), self).into_mut();
         cx.run_until_parked();
         cx
     }
@@ -273,7 +274,7 @@ impl TestAppContext {
             .unwrap();
         drop(cx);
         let view = window.root(self).unwrap();
-        let cx = VisualTestContext::from_window(*window.deref(), self).as_mut();
+        let cx = VisualTestContext::from_window(*window.deref(), self).into_mut();
         cx.run_until_parked();
 
         // it might be nice to try and cleanup these at the end of each test.
@@ -882,7 +883,7 @@ impl VisualTestContext {
 
     /// Get an &mut VisualTestContext (which is mostly what you need to pass to other methods).
     /// This method internally retains the VisualTestContext until the end of the test.
-    pub fn as_mut(self) -> &'static mut Self {
+    pub fn into_mut(self) -> &'static mut Self {
         let ptr = Box::into_raw(Box::new(self));
         // safety: on_quit will be called after the test has finished.
         // the executor will ensure that all tasks related to the test have stopped.

crates/gpui/src/color.rs

@@ -905,9 +905,9 @@ mod tests {
         assert_eq!(background.solid, color);
 
         assert_eq!(background.opacity(0.5).solid, color.opacity(0.5));
-        assert_eq!(background.is_transparent(), false);
+        assert!(!background.is_transparent());
         background.solid = hsla(0.0, 0.0, 0.0, 0.0);
-        assert_eq!(background.is_transparent(), true);
+        assert!(background.is_transparent());
     }
 
     #[test]
@@ -921,7 +921,7 @@ mod tests {
 
         assert_eq!(background.opacity(0.5).colors[0], from.opacity(0.5));
         assert_eq!(background.opacity(0.5).colors[1], to.opacity(0.5));
-        assert_eq!(background.is_transparent(), false);
-        assert_eq!(background.opacity(0.0).is_transparent(), true);
+        assert!(!background.is_transparent());
+        assert!(background.opacity(0.0).is_transparent());
     }
 }

crates/gpui/src/geometry.rs

@@ -1641,7 +1641,7 @@ impl Bounds<Pixels> {
     }
 
     /// Convert the bounds from logical pixels to physical pixels
-    pub fn to_device_pixels(&self, factor: f32) -> Bounds<DevicePixels> {
+    pub fn to_device_pixels(self, factor: f32) -> Bounds<DevicePixels> {
         Bounds {
             origin: point(
                 DevicePixels((self.origin.x.0 * factor).round() as i32),
@@ -1957,7 +1957,7 @@ impl Edges<DefiniteLength> {
     /// assert_eq!(edges_in_pixels.bottom, px(32.0)); // 2 rems
     /// assert_eq!(edges_in_pixels.left, px(50.0)); // 25% of parent width
     /// ```
-    pub fn to_pixels(&self, parent_size: Size<AbsoluteLength>, rem_size: Pixels) -> Edges<Pixels> {
+    pub fn to_pixels(self, parent_size: Size<AbsoluteLength>, rem_size: Pixels) -> Edges<Pixels> {
         Edges {
             top: self.top.to_pixels(parent_size.height, rem_size),
             right: self.right.to_pixels(parent_size.width, rem_size),
@@ -2027,7 +2027,7 @@ impl Edges<AbsoluteLength> {
     /// assert_eq!(edges_in_pixels.bottom, px(20.0)); // Already in pixels
     /// assert_eq!(edges_in_pixels.left, px(32.0)); // 2 rems converted to pixels
     /// ```
-    pub fn to_pixels(&self, rem_size: Pixels) -> Edges<Pixels> {
+    pub fn to_pixels(self, rem_size: Pixels) -> Edges<Pixels> {
         Edges {
             top: self.top.to_pixels(rem_size),
             right: self.right.to_pixels(rem_size),
@@ -2272,7 +2272,7 @@ impl Corners<AbsoluteLength> {
     /// assert_eq!(corners_in_pixels.bottom_right, Pixels(30.0));
     /// assert_eq!(corners_in_pixels.bottom_left, Pixels(32.0)); // 2 rems converted to pixels
     /// ```
-    pub fn to_pixels(&self, rem_size: Pixels) -> Corners<Pixels> {
+    pub fn to_pixels(self, rem_size: Pixels) -> Corners<Pixels> {
         Corners {
             top_left: self.top_left.to_pixels(rem_size),
             top_right: self.top_right.to_pixels(rem_size),
@@ -2858,7 +2858,7 @@ impl DevicePixels {
     /// let total_bytes = pixels.to_bytes(bytes_per_pixel);
     /// assert_eq!(total_bytes, 40); // 10 pixels * 4 bytes/pixel = 40 bytes
     /// ```
-    pub fn to_bytes(&self, bytes_per_pixel: u8) -> u32 {
+    pub fn to_bytes(self, bytes_per_pixel: u8) -> u32 {
         self.0 as u32 * bytes_per_pixel as u32
     }
 }
@@ -3073,8 +3073,8 @@ pub struct Rems(pub f32);
 
 impl Rems {
     /// Convert this Rem value to pixels.
-    pub fn to_pixels(&self, rem_size: Pixels) -> Pixels {
-        *self * rem_size
+    pub fn to_pixels(self, rem_size: Pixels) -> Pixels {
+        self * rem_size
     }
 }
 
@@ -3168,9 +3168,9 @@ impl AbsoluteLength {
     /// assert_eq!(length_in_pixels.to_pixels(rem_size), Pixels(42.0));
     /// assert_eq!(length_in_rems.to_pixels(rem_size), Pixels(32.0));
     /// ```
-    pub fn to_pixels(&self, rem_size: Pixels) -> Pixels {
+    pub fn to_pixels(self, rem_size: Pixels) -> Pixels {
         match self {
-            AbsoluteLength::Pixels(pixels) => *pixels,
+            AbsoluteLength::Pixels(pixels) => pixels,
             AbsoluteLength::Rems(rems) => rems.to_pixels(rem_size),
         }
     }
@@ -3184,10 +3184,10 @@ impl AbsoluteLength {
     /// # Returns
     ///
     /// Returns the `AbsoluteLength` as `Pixels`.
-    pub fn to_rems(&self, rem_size: Pixels) -> Rems {
+    pub fn to_rems(self, rem_size: Pixels) -> Rems {
         match self {
             AbsoluteLength::Pixels(pixels) => Rems(pixels.0 / rem_size.0),
-            AbsoluteLength::Rems(rems) => *rems,
+            AbsoluteLength::Rems(rems) => rems,
         }
     }
 }
@@ -3315,12 +3315,12 @@ impl DefiniteLength {
     /// assert_eq!(length_in_rems.to_pixels(base_size, rem_size), Pixels(32.0));
     /// assert_eq!(length_as_fraction.to_pixels(base_size, rem_size), Pixels(50.0));
     /// ```
-    pub fn to_pixels(&self, base_size: AbsoluteLength, rem_size: Pixels) -> Pixels {
+    pub fn to_pixels(self, base_size: AbsoluteLength, rem_size: Pixels) -> Pixels {
         match self {
             DefiniteLength::Absolute(size) => size.to_pixels(rem_size),
             DefiniteLength::Fraction(fraction) => match base_size {
-                AbsoluteLength::Pixels(px) => px * *fraction,
-                AbsoluteLength::Rems(rems) => rems * rem_size * *fraction,
+                AbsoluteLength::Pixels(px) => px * fraction,
+                AbsoluteLength::Rems(rems) => rems * rem_size * fraction,
             },
         }
     }

crates/gpui/src/gpui.rs

@@ -172,6 +172,10 @@ pub trait AppContext {
     type Result<T>;
 
     /// Create a new entity in the app context.
+    #[expect(
+        clippy::wrong_self_convention,
+        reason = "`App::new` is an ubiquitous function for creating entities"
+    )]
     fn new<T: 'static>(
         &mut self,
         build_entity: impl FnOnce(&mut Context<T>) -> T,

crates/gpui/src/keymap.rs

@@ -364,29 +364,29 @@ mod tests {
         // Ensure `space` results in pending input on the workspace, but not editor
         let space_workspace = keymap.bindings_for_input(&[space()], &workspace_context());
         assert!(space_workspace.0.is_empty());
-        assert_eq!(space_workspace.1, true);
+        assert!(space_workspace.1);
 
         let space_editor = keymap.bindings_for_input(&[space()], &editor_workspace_context());
         assert!(space_editor.0.is_empty());
-        assert_eq!(space_editor.1, false);
+        assert!(!space_editor.1);
 
         // Ensure `space w` results in pending input on the workspace, but not editor
         let space_w_workspace = keymap.bindings_for_input(&space_w, &workspace_context());
         assert!(space_w_workspace.0.is_empty());
-        assert_eq!(space_w_workspace.1, true);
+        assert!(space_w_workspace.1);
 
         let space_w_editor = keymap.bindings_for_input(&space_w, &editor_workspace_context());
         assert!(space_w_editor.0.is_empty());
-        assert_eq!(space_w_editor.1, false);
+        assert!(!space_w_editor.1);
 
         // Ensure `space w w` results in the binding in the workspace, but not in the editor
         let space_w_w_workspace = keymap.bindings_for_input(&space_w_w, &workspace_context());
         assert!(!space_w_w_workspace.0.is_empty());
-        assert_eq!(space_w_w_workspace.1, false);
+        assert!(!space_w_w_workspace.1);
 
         let space_w_w_editor = keymap.bindings_for_input(&space_w_w, &editor_workspace_context());
         assert!(space_w_w_editor.0.is_empty());
-        assert_eq!(space_w_w_editor.1, false);
+        assert!(!space_w_w_editor.1);
 
         // Now test what happens if we have another binding defined AFTER the NoAction
         // that should result in pending
@@ -400,7 +400,7 @@ mod tests {
 
         let space_editor = keymap.bindings_for_input(&[space()], &editor_workspace_context());
         assert!(space_editor.0.is_empty());
-        assert_eq!(space_editor.1, true);
+        assert!(space_editor.1);
 
         // Now test what happens if we have another binding defined BEFORE the NoAction
         // that should result in pending
@@ -414,7 +414,7 @@ mod tests {
 
         let space_editor = keymap.bindings_for_input(&[space()], &editor_workspace_context());
         assert!(space_editor.0.is_empty());
-        assert_eq!(space_editor.1, true);
+        assert!(space_editor.1);
 
         // Now test what happens if we have another binding defined at a higher context
         // that should result in pending
@@ -428,7 +428,7 @@ mod tests {
 
         let space_editor = keymap.bindings_for_input(&[space()], &editor_workspace_context());
         assert!(space_editor.0.is_empty());
-        assert_eq!(space_editor.1, true);
+        assert!(space_editor.1);
     }
 
     #[test]
@@ -447,7 +447,7 @@ mod tests {
             &[KeyContext::parse("editor").unwrap()],
         );
         assert!(result.is_empty());
-        assert_eq!(pending, true);
+        assert!(pending);
 
         let bindings = [
             KeyBinding::new("ctrl-w left", ActionAlpha {}, Some("editor")),
@@ -463,7 +463,7 @@ mod tests {
             &[KeyContext::parse("editor").unwrap()],
         );
         assert_eq!(result.len(), 1);
-        assert_eq!(pending, false);
+        assert!(!pending);
     }
 
     #[test]
@@ -482,7 +482,7 @@ mod tests {
             &[KeyContext::parse("editor").unwrap()],
         );
         assert!(result.is_empty());
-        assert_eq!(pending, false);
+        assert!(!pending);
     }
 
     #[test]
@@ -505,7 +505,7 @@ mod tests {
             ],
         );
         assert_eq!(result.len(), 1);
-        assert_eq!(pending, false);
+        assert!(!pending);
     }
 
     #[test]
@@ -527,7 +527,7 @@ mod tests {
             ],
         );
         assert_eq!(result.len(), 0);
-        assert_eq!(pending, false);
+        assert!(!pending);
     }
 
     #[test]

crates/gpui/src/keymap/binding.rs

@@ -30,11 +30,8 @@ impl Clone for KeyBinding {
 impl KeyBinding {
     /// Construct a new keybinding from the given data. Panics on parse error.
     pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self {
-        let context_predicate = if let Some(context) = context {
-            Some(KeyBindingContextPredicate::parse(context).unwrap().into())
-        } else {
-            None
-        };
+        let context_predicate =
+            context.map(|context| KeyBindingContextPredicate::parse(context).unwrap().into());
         Self::load(keystrokes, Box::new(action), context_predicate, None, None).unwrap()
     }
 

crates/gpui/src/platform.rs

@@ -673,7 +673,7 @@ impl PlatformTextSystem for NoopTextSystem {
             }
         }
         let mut runs = Vec::default();
-        if glyphs.len() > 0 {
+        if !glyphs.is_empty() {
             runs.push(ShapedRun {
                 font_id: FontId(0),
                 glyphs,

crates/gpui/src/platform/linux/platform.rs

@@ -667,7 +667,7 @@ pub(super) const DEFAULT_CURSOR_ICON_NAME: &str = "left_ptr";
 
 impl CursorStyle {
     #[cfg(any(feature = "wayland", feature = "x11"))]
-    pub(super) fn to_icon_names(&self) -> &'static [&'static str] {
+    pub(super) fn to_icon_names(self) -> &'static [&'static str] {
         // Based on cursor names from chromium:
         // https://github.com/chromium/chromium/blob/d3069cf9c973dc3627fa75f64085c6a86c8f41bf/ui/base/cursor/cursor_factory.cc#L113
         match self {
@@ -990,21 +990,18 @@ mod tests {
     #[test]
     fn test_is_within_click_distance() {
         let zero = Point::new(px(0.0), px(0.0));
-        assert_eq!(
-            is_within_click_distance(zero, Point::new(px(5.0), px(5.0))),
-            true
-        );
-        assert_eq!(
-            is_within_click_distance(zero, Point::new(px(-4.9), px(5.0))),
-            true
-        );
-        assert_eq!(
-            is_within_click_distance(Point::new(px(3.0), px(2.0)), Point::new(px(-2.0), px(-2.0))),
-            true
-        );
-        assert_eq!(
-            is_within_click_distance(zero, Point::new(px(5.0), px(5.1))),
-            false
-        );
+        assert!(is_within_click_distance(zero, Point::new(px(5.0), px(5.0))));
+        assert!(is_within_click_distance(
+            zero,
+            Point::new(px(-4.9), px(5.0))
+        ));
+        assert!(is_within_click_distance(
+            Point::new(px(3.0), px(2.0)),
+            Point::new(px(-2.0), px(-2.0))
+        ));
+        assert!(!is_within_click_distance(
+            zero,
+            Point::new(px(5.0), px(5.1))
+        ),);
     }
 }

crates/gpui/src/platform/linux/wayland.rs

@@ -12,7 +12,7 @@ use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::
 use crate::CursorStyle;
 
 impl CursorStyle {
-    pub(super) fn to_shape(&self) -> Shape {
+    pub(super) fn to_shape(self) -> Shape {
         match self {
             CursorStyle::Arrow => Shape::Default,
             CursorStyle::IBeam => Shape::Text,

crates/gpui/src/platform/linux/wayland/window.rs

@@ -1139,7 +1139,7 @@ fn update_window(mut state: RefMut<WaylandWindowState>) {
 }
 
 impl WindowDecorations {
-    fn to_xdg(&self) -> zxdg_toplevel_decoration_v1::Mode {
+    fn to_xdg(self) -> zxdg_toplevel_decoration_v1::Mode {
         match self {
             WindowDecorations::Client => zxdg_toplevel_decoration_v1::Mode::ClientSide,
             WindowDecorations::Server => zxdg_toplevel_decoration_v1::Mode::ServerSide,
@@ -1148,7 +1148,7 @@ impl WindowDecorations {
 }
 
 impl ResizeEdge {
-    fn to_xdg(&self) -> xdg_toplevel::ResizeEdge {
+    fn to_xdg(self) -> xdg_toplevel::ResizeEdge {
         match self {
             ResizeEdge::Top => xdg_toplevel::ResizeEdge::Top,
             ResizeEdge::TopRight => xdg_toplevel::ResizeEdge::TopRight,

crates/gpui/src/platform/linux/x11/window.rs

@@ -95,7 +95,7 @@ fn query_render_extent(
 }
 
 impl ResizeEdge {
-    fn to_moveresize(&self) -> u32 {
+    fn to_moveresize(self) -> u32 {
         match self {
             ResizeEdge::TopLeft => 0,
             ResizeEdge::Top => 1,

crates/gpui/src/platform/mac/window.rs

@@ -1090,7 +1090,7 @@ impl PlatformWindow for MacWindow {
                         NSView::removeFromSuperview(blur_view);
                         this.blurred_view = None;
                     }
-                } else if this.blurred_view == None {
+                } else if this.blurred_view.is_none() {
                     let content_view = this.native_window.contentView();
                     let frame = NSView::bounds(content_view);
                     let mut blur_view: id = msg_send![BLURRED_VIEW_CLASS, alloc];

crates/gpui/src/tab_stop.rs

@@ -45,27 +45,18 @@ impl TabHandles {
             })
             .unwrap_or_default();
 
-        if let Some(next_handle) = self.handles.get(next_ix) {
-            Some(next_handle.clone())
-        } else {
-            None
-        }
+        self.handles.get(next_ix).cloned()
     }
 
     pub(crate) fn prev(&self, focused_id: Option<&FocusId>) -> Option<FocusHandle> {
         let ix = self.current_index(focused_id).unwrap_or_default();
-        let prev_ix;
-        if ix == 0 {
-            prev_ix = self.handles.len().saturating_sub(1);
+        let prev_ix = if ix == 0 {
+            self.handles.len().saturating_sub(1)
         } else {
-            prev_ix = ix.saturating_sub(1);
-        }
+            ix.saturating_sub(1)
+        };
 
-        if let Some(prev_handle) = self.handles.get(prev_ix) {
-            Some(prev_handle.clone())
-        } else {
-            None
-        }
+        self.handles.get(prev_ix).cloned()
     }
 }