From 2d8636c6449b3696c5239175a4dd1920d58e2c9f Mon Sep 17 00:00:00 2001
From: dcz <gilapfco.dcz@porcupinefactory.org>
Date: Sun, 8 Feb 2026 17:36:44 +0000
Subject: [PATCH] Bump MSRV to 1.91

Needed for UTF code point navigation in https://github.com/lapce/floem/pull/1028
---
 Cargo.toml                        |   2 +-
 src/animate/mod.rs                |  18 ++--
 src/app/handle.rs                 |  24 ++---
 src/event/dispatch.rs             | 166 ++++++++++++++----------------
 src/event/path.rs                 | 105 +++++++++----------
 src/inspector/view.rs             |  27 ++---
 src/paint/mod.rs                  |  16 +--
 src/platform/context_menu.rs      |  16 +--
 src/style/cache.rs                |  67 ++++++------
 src/style/mod.rs                  |   8 +-
 src/style/transition.rs           |  14 +--
 src/view/id.rs                    |  32 +++---
 src/views/decorator.rs            |  16 +--
 src/views/drag_window_area.rs     |   8 +-
 src/views/dyn_stack.rs            |  24 ++---
 src/views/editor/actions.rs       |   6 +-
 src/views/editor/movement.rs      |  36 +++----
 src/views/editor/text_document.rs |  23 ++---
 src/views/editor/view.rs          |   8 +-
 src/views/editor/visual_line.rs   |  54 +++++-----
 src/views/label.rs                |  26 ++---
 src/views/scroll.rs               |  33 +++---
 src/views/svg.rs                  |  10 +-
 src/views/tab.rs                  |   9 +-
 src/views/text_input.rs           |   8 +-
 src/views/toggle_button.rs        |   8 +-
 src/views/tooltip.rs              |  30 +++---
 src/views/value_container.rs      |   8 +-
 src/views/virtual_stack.rs        |  14 +--
 src/window/handle.rs              |  18 ++--
 30 files changed, 406 insertions(+), 428 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6c209817c..6f19c1db1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ default-members = [
 license = "MIT"
 version = "0.2.0"
 edition = "2024"
-rust-version = "1.87"
+rust-version = "1.91"
 repository = "https://github.com/lapce/floem"
 
 [package]
diff --git a/src/animate/mod.rs b/src/animate/mod.rs
index 9a24152e2..119744a09 100644
--- a/src/animate/mod.rs
+++ b/src/animate/mod.rs
@@ -222,10 +222,10 @@ impl PropCache {
     }
 
     fn remove_prop(&mut self, prop: StylePropRef, idx: u16) {
-        if let imbl::hashmap::Entry::Occupied(mut oe) = self.prop_map.entry(prop) {
-            if let Ok(pos) = oe.get().binary_search(&PropFrameKind::Normal(idx)) {
-                oe.get_mut().remove(pos);
-            }
+        if let imbl::hashmap::Entry::Occupied(mut oe) = self.prop_map.entry(prop)
+            && let Ok(pos) = oe.get().binary_search(&PropFrameKind::Normal(idx))
+        {
+            oe.get_mut().remove(pos);
         }
     }
 
@@ -510,11 +510,11 @@ impl Animation {
     ) -> Self {
         let frame = key_frame(KeyFrame::new(frame_id));
         let frame_style = frame.style.clone();
-        if let Some(f) = self.key_frames.insert(frame_id, frame) {
-            if let KeyFrameStyle::Style(style) = f.style {
-                for prop in style.style_props() {
-                    self.cache.remove_prop(prop, frame_id);
-                }
+        if let Some(f) = self.key_frames.insert(frame_id, frame)
+            && let KeyFrameStyle::Style(style) = f.style
+        {
+            for prop in style.style_props() {
+                self.cache.remove_prop(prop, frame_id);
             }
         }
         if let KeyFrameStyle::Style(style) = frame_style {
diff --git a/src/app/handle.rs b/src/app/handle.rs
index 05f460392..dc5f9aa6b 100644
--- a/src/app/handle.rs
+++ b/src/app/handle.rs
@@ -229,10 +229,10 @@ impl ApplicationHandle {
             .reduce(window_handle.scale, &event)
         {
             Some(WindowEventTranslation::Keyboard(ke)) => {
-                if let WindowEvent::KeyboardInput { is_synthetic, .. } = event {
-                    if !is_synthetic {
-                        window_handle.key_event(ke)
-                    }
+                if let WindowEvent::KeyboardInput { is_synthetic, .. } = event
+                    && !is_synthetic
+                {
+                    window_handle.key_event(ke)
                 }
             }
             Some(WindowEventTranslation::Pointer(pe)) => {
@@ -538,16 +538,16 @@ impl ApplicationHandle {
             return;
         };
         #[cfg(target_os = "macos")]
-        if let Some(mac) = &mac_os_config {
-            if let Some((x, y)) = mac.traffic_lights_offset {
-                use raw_window_handle::HasWindowHandle;
+        if let Some(mac) = &mac_os_config
+            && let Some((x, y)) = mac.traffic_lights_offset
+        {
+            use raw_window_handle::HasWindowHandle;
 
-                if let Ok(wh) = window.window_handle() {
-                    use raw_window_handle::RawWindowHandle;
+            if let Ok(wh) = window.window_handle() {
+                use raw_window_handle::RawWindowHandle;
 
-                    if let RawWindowHandle::AppKit(app_kit) = wh.as_raw() {
-                        let _ = setup_traffic_light_constraints_all_pixels(&app_kit, x, y, 6.);
-                    }
+                if let RawWindowHandle::AppKit(app_kit) = wh.as_raw() {
+                    let _ = setup_traffic_light_constraints_all_pixels(&app_kit, x, y, 6.);
                 }
             }
         }
diff --git a/src/event/dispatch.rs b/src/event/dispatch.rs
index 62539fe9b..2ec401478 100644
--- a/src/event/dispatch.rs
+++ b/src/event/dispatch.rs
@@ -389,15 +389,14 @@ impl EventCx<'_> {
         // IMPORTANT: This is set AFTER event dispatch, matching Chromium's timing.
         // This allows handlers during PointerDown to call releasePointerCapture()
         // to prevent implicit capture if desired.
-        if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { pointer, .. })) = event {
-            if pointer.pointer_type == PointerType::Touch {
-                if let Some(pointer_id) = pointer.pointer_id {
-                    // Only set implicit capture if no explicit capture was set during dispatch
-                    // and no explicit release was requested
-                    if !self.window_state.has_pending_capture(pointer_id) {
-                        self.window_state.set_pointer_capture(pointer_id, target);
-                    }
-                }
+        if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { pointer, .. })) = event
+            && pointer.pointer_type == PointerType::Touch
+            && let Some(pointer_id) = pointer.pointer_id
+        {
+            // Only set implicit capture if no explicit capture was set during dispatch
+            // and no explicit release was requested
+            if !self.window_state.has_pending_capture(pointer_id) {
+                self.window_state.set_pointer_capture(pointer_id, target);
             }
         }
 
@@ -535,12 +534,10 @@ impl EventCx<'_> {
             processed |= self.dispatch_to_view(id, event, true).is_processed();
         }
 
-        if !processed {
-            if let Some(listener) = event.listener() {
-                processed |= main_view_id
-                    .apply_event(&listener, event)
-                    .is_some_and(|prop| prop.is_processed());
-            }
+        if !processed && let Some(listener) = event.listener() {
+            processed |= main_view_id
+                .apply_event(&listener, event)
+                .is_some_and(|prop| prop.is_processed());
         }
 
         if !processed {
@@ -557,16 +554,15 @@ impl EventCx<'_> {
                 {
                     let backwards = modifiers.contains(Modifiers::SHIFT);
                     view_tab_navigation(root_id, self.window_state, backwards);
-                } else if *modifiers == Modifiers::ALT {
-                    if let Key::Named(
+                } else if *modifiers == Modifiers::ALT
+                    && let Key::Named(
                         name @ (NamedKey::ArrowUp
                         | NamedKey::ArrowDown
                         | NamedKey::ArrowLeft
                         | NamedKey::ArrowRight),
                     ) = key
-                    {
-                        view_arrow_navigation(*name, self.window_state, root_id);
-                    }
+                {
+                    view_arrow_navigation(*name, self.window_state, root_id);
                 }
             }
 
@@ -580,16 +576,14 @@ impl EventCx<'_> {
                         ..
                     })
                 );
-            if keyboard_trigger_end {
-                if let Some(id) = self.window_state.active {
-                    if self
-                        .window_state
-                        .has_style_for_sel(id, StyleSelector::Active)
-                    {
-                        id.request_style_for_selector_recursive(StyleSelector::Active);
-                    }
-                    self.window_state.active = None;
+            if keyboard_trigger_end && let Some(id) = self.window_state.active {
+                if self
+                    .window_state
+                    .has_style_for_sel(id, StyleSelector::Active)
+                {
+                    id.request_style_for_selector_recursive(StyleSelector::Active);
                 }
+                self.window_state.active = None;
             }
         }
     }
@@ -674,20 +668,19 @@ impl EventCx<'_> {
         view_state: &std::cell::RefCell<crate::view::ViewState>,
         event: &Event,
     ) {
-        if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { state, .. })) = event {
-            if view_state.borrow().computed_style.get(Focusable) {
-                let rect = view_id.get_size().unwrap_or_default().to_rect();
-                if rect.contains(state.logical_point()) {
-                    self.window_state.update_focus(view_id, false);
-                }
+        if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { state, .. })) = event
+            && view_state.borrow().computed_style.get(Focusable)
+        {
+            let rect = view_id.get_size().unwrap_or_default().to_rect();
+            if rect.contains(state.logical_point()) {
+                self.window_state.update_focus(view_id, false);
             }
         }
-        if let Event::Pointer(PointerEvent::Move(_)) = event {
-            if let Some(cursor) = view_state.borrow().combined_style.builtin().cursor() {
-                if self.window_state.cursor.is_none() {
-                    self.window_state.cursor = Some(cursor);
-                }
-            }
+        if let Event::Pointer(PointerEvent::Move(_)) = event
+            && let Some(cursor) = view_state.borrow().combined_style.builtin().cursor()
+            && self.window_state.cursor.is_none()
+        {
+            self.window_state.cursor = Some(cursor);
         }
     }
 
@@ -857,46 +850,45 @@ impl EventCx<'_> {
                     self.window_state.hovered.push(view_id);
                 }
                 let vs = view_state.borrow();
-                if let Some(cursor) = vs.combined_style.builtin().cursor() {
-                    if self.window_state.cursor.is_none() {
-                        self.window_state.cursor = Some(cursor);
-                    }
+                if let Some(cursor) = vs.combined_style.builtin().cursor()
+                    && self.window_state.cursor.is_none()
+                {
+                    self.window_state.cursor = Some(cursor);
                 }
             }
         }
 
         // Handle drag state updates
-        if view_id.can_drag() {
-            if let Some((_, drag_start)) = self
+        if view_id.can_drag()
+            && let Some((_, drag_start)) = self
                 .window_state
                 .drag_start
                 .as_ref()
                 .filter(|(drag_id, _)| drag_id == &view_id)
-            {
-                let offset = point - *drag_start;
+        {
+            let offset = point - *drag_start;
 
-                if let Some(dragging) = self
-                    .window_state
-                    .dragging
-                    .as_mut()
-                    .filter(|d| d.id == view_id && d.released_at.is_none())
-                {
-                    // Update position while dragging
-                    dragging.offset = drag_start.to_vec2();
-                    self.window_state.request_paint(view_id);
-                } else if offset.x.abs() + offset.y.abs() > 1.0 {
-                    // Start dragging when moved > 1px
-                    self.window_state.active = None;
-                    self.window_state.dragging = Some(DragState {
-                        id: view_id,
-                        offset: drag_start.to_vec2(),
-                        released_at: None,
-                        release_location: None,
-                    });
-                    self.update_active(view_id);
-                    self.window_state.request_paint(view_id);
-                    view_id.apply_event(&EventListener::DragStart, event);
-                }
+            if let Some(dragging) = self
+                .window_state
+                .dragging
+                .as_mut()
+                .filter(|d| d.id == view_id && d.released_at.is_none())
+            {
+                // Update position while dragging
+                dragging.offset = drag_start.to_vec2();
+                self.window_state.request_paint(view_id);
+            } else if offset.x.abs() + offset.y.abs() > 1.0 {
+                // Start dragging when moved > 1px
+                self.window_state.active = None;
+                self.window_state.dragging = Some(DragState {
+                    id: view_id,
+                    offset: drag_start.to_vec2(),
+                    released_at: None,
+                    release_location: None,
+                });
+                self.update_active(view_id);
+                self.window_state.request_paint(view_id);
+                view_id.apply_event(&EventListener::DragStart, event);
             }
         }
 
@@ -928,25 +920,21 @@ impl EventCx<'_> {
         if pointer.is_primary_pointer() && button.is_none_or(|b| b == PointerButton::Primary) {
             // Show popout menu on non-macOS (pointer up)
             #[cfg(not(target_os = "macos"))]
-            if on_view {
-                if let Some(result) = self.try_show_popout_menu(view_id) {
-                    return Some(result);
-                }
+            if on_view && let Some(result) = self.try_show_popout_menu(view_id) {
+                return Some(result);
             }
 
             // Handle drag drop
             if !directed {
-                if on_view {
-                    if let Some(dragging) = self.window_state.dragging.as_mut() {
-                        let dragging_id = dragging.id;
-                        if view_id
-                            .apply_event(&EventListener::Drop, event)
-                            .is_some_and(|prop| prop.is_processed())
-                        {
-                            self.window_state.dragging = None;
-                            self.window_state.request_paint(view_id);
-                            dragging_id.apply_event(&EventListener::DragEnd, event);
-                        }
+                if on_view && let Some(dragging) = self.window_state.dragging.as_mut() {
+                    let dragging_id = dragging.id;
+                    if view_id
+                        .apply_event(&EventListener::Drop, event)
+                        .is_some_and(|prop| prop.is_processed())
+                    {
+                        self.window_state.dragging = None;
+                        self.window_state.request_paint(view_id);
+                        dragging_id.apply_event(&EventListener::DragEnd, event);
                     }
                 }
             } else if let Some(dragging) = self
@@ -1008,10 +996,8 @@ impl EventCx<'_> {
                 return Some(result);
             }
 
-            if on_view {
-                if let Some(result) = self.try_show_context_menu(view_id, state) {
-                    return Some(result);
-                }
+            if on_view && let Some(result) = self.try_show_context_menu(view_id, state) {
+                return Some(result);
             }
         }
 
diff --git a/src/event/path.rs b/src/event/path.rs
index 85a1eec98..55a4489f1 100644
--- a/src/event/path.rs
+++ b/src/event/path.rs
@@ -485,12 +485,12 @@ pub fn dispatch_through_path(
         }
 
         // Call event listeners
-        if !node.has_disabled_defaults {
-            if let Some(listener) = local_event.listener() {
-                let result = node.view_id.apply_event(&listener, &local_event);
-                if result.is_some_and(|r| r.is_processed()) {
-                    return DispatchResult::Processed;
-                }
+        if !node.has_disabled_defaults
+            && let Some(listener) = local_event.listener()
+        {
+            let result = node.view_id.apply_event(&listener, &local_event);
+            if result.is_some_and(|r| r.is_processed()) {
+                return DispatchResult::Processed;
             }
         }
     }
@@ -650,12 +650,12 @@ fn handle_focus_on_processed(
     use super::Event;
     use ui_events::pointer::{PointerButtonEvent, PointerEvent};
 
-    if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { state, .. })) = event {
-        if node.is_focusable {
-            let rect = node.view_id.get_size().unwrap_or_default().to_rect();
-            if rect.contains(state.logical_point()) {
-                cx.window_state.update_focus(node.view_id, false);
-            }
+    if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { state, .. })) = event
+        && node.is_focusable
+    {
+        let rect = node.view_id.get_size().unwrap_or_default().to_rect();
+        if rect.contains(state.logical_point()) {
+            cx.window_state.update_focus(node.view_id, false);
         }
     }
 }
@@ -771,42 +771,41 @@ fn handle_builtin_behaviors(
                         cx.window_state.hovered.push(view_id);
                     }
                     let cursor = view_state.borrow().combined_style.builtin().cursor();
-                    if let Some(cursor) = cursor {
-                        if cx.window_state.cursor.is_none() {
-                            cx.window_state.cursor = Some(cursor);
-                        }
+                    if let Some(cursor) = cursor
+                        && cx.window_state.cursor.is_none()
+                    {
+                        cx.window_state.cursor = Some(cursor);
                     }
                 }
             }
 
             // Drag handling
-            if node.can_drag {
-                if let Some((drag_id, drag_start)) = cx.window_state.drag_start.as_ref() {
-                    if drag_id == &view_id {
-                        let drag_start = *drag_start;
-                        let offset = current.logical_point() - drag_start;
-
-                        if let Some(dragging) = cx
-                            .window_state
-                            .dragging
-                            .as_mut()
-                            .filter(|d| d.id == view_id && d.released_at.is_none())
-                        {
-                            dragging.offset = drag_start.to_vec2();
-                            cx.window_state.request_paint(view_id);
-                        } else if offset.x.abs() + offset.y.abs() > 1.0 {
-                            cx.window_state.active = None;
-                            cx.window_state.dragging = Some(DragState {
-                                id: view_id,
-                                offset: drag_start.to_vec2(),
-                                released_at: None,
-                                release_location: None,
-                            });
-                            cx.update_active(view_id);
-                            cx.window_state.request_paint(view_id);
-                            view_id.apply_event(&super::EventListener::DragStart, local_event);
-                        }
-                    }
+            if node.can_drag
+                && let Some((drag_id, drag_start)) = cx.window_state.drag_start.as_ref()
+                && drag_id == &view_id
+            {
+                let drag_start = *drag_start;
+                let offset = current.logical_point() - drag_start;
+
+                if let Some(dragging) = cx
+                    .window_state
+                    .dragging
+                    .as_mut()
+                    .filter(|d| d.id == view_id && d.released_at.is_none())
+                {
+                    dragging.offset = drag_start.to_vec2();
+                    cx.window_state.request_paint(view_id);
+                } else if offset.x.abs() + offset.y.abs() > 1.0 {
+                    cx.window_state.active = None;
+                    cx.window_state.dragging = Some(DragState {
+                        id: view_id,
+                        offset: drag_start.to_vec2(),
+                        released_at: None,
+                        release_location: None,
+                    });
+                    cx.update_active(view_id);
+                    cx.window_state.request_paint(view_id);
+                    view_id.apply_event(&super::EventListener::DragStart, local_event);
                 }
             }
         }
@@ -821,17 +820,15 @@ fn handle_builtin_behaviors(
                 let on_view = rect.contains(state.logical_point());
 
                 // Handle drop
-                if on_view {
-                    if let Some(dragging) = cx.window_state.dragging.as_mut() {
-                        let dragging_id = dragging.id;
-                        if view_id
-                            .apply_event(&super::EventListener::Drop, local_event)
-                            .is_some_and(|prop| prop.is_processed())
-                        {
-                            cx.window_state.dragging = None;
-                            cx.window_state.request_paint(view_id);
-                            dragging_id.apply_event(&super::EventListener::DragEnd, local_event);
-                        }
+                if on_view && let Some(dragging) = cx.window_state.dragging.as_mut() {
+                    let dragging_id = dragging.id;
+                    if view_id
+                        .apply_event(&super::EventListener::Drop, local_event)
+                        .is_some_and(|prop| prop.is_processed())
+                    {
+                        cx.window_state.dragging = None;
+                        cx.window_state.request_paint(view_id);
+                        dragging_id.apply_event(&super::EventListener::DragEnd, local_event);
                     }
                 }
 
diff --git a/src/inspector/view.rs b/src/inspector/view.rs
index 031d09566..b32e43268 100644
--- a/src/inspector/view.rs
+++ b/src/inspector/view.rs
@@ -76,11 +76,12 @@ pub fn capture(window_id: WindowId) {
                 stack
                     .style(|s| s.width_full().height_full())
                     .on_event(EventListener::KeyUp, move |e| {
-                        if let Event::Key(e) = e {
-                            if e.key == keyboard::Key::Named(NamedKey::F11) && e.modifiers.shift() {
-                                id.inspect();
-                                return EventPropagation::Stop;
-                            }
+                        if let Event::Key(e) = e
+                            && e.key == keyboard::Key::Named(NamedKey::F11)
+                            && e.modifiers.shift()
+                        {
+                            id.inspect();
+                            return EventPropagation::Stop;
                         }
                         EventPropagation::Continue
                     })
@@ -558,14 +559,14 @@ fn tree_node(
     let scroll_to = capture_signal.scroll_to;
     let expanding_selection = capture_signal.expanding_selection;
     Effect::new(move |_| {
-        if let Some((selection, request_focus)) = expanding_selection.get() {
-            if selection == id {
-                // Scroll to the row, then to the name part of the row.
-                scroll_to.set(Some(row_id));
-                scroll_to.set(Some(name_id));
-                if request_focus {
-                    row_id.request_focus();
-                }
+        if let Some((selection, request_focus)) = expanding_selection.get()
+            && selection == id
+        {
+            // Scroll to the row, then to the name part of the row.
+            scroll_to.set(Some(row_id));
+            scroll_to.set(Some(name_id));
+            if request_focus {
+                row_id.request_focus();
             }
         }
     });
diff --git a/src/paint/mod.rs b/src/paint/mod.rs
index 3392d2cbb..3c7488e82 100644
--- a/src/paint/mod.rs
+++ b/src/paint/mod.rs
@@ -243,14 +243,14 @@ impl PaintCx<'_> {
             paint_outline(self, &view_style_props, size)
         }
         // Check if this view is being dragged and needs deferred painting
-        if let Some(dragging) = self.window_state.dragging.as_ref() {
-            if dragging.id == id {
-                // Store the pending drag paint info - actual painting happens after tree traversal
-                self.pending_drag_paint = Some(PendingDragPaint {
-                    id,
-                    base_transform: self.transform,
-                });
-            }
+        if let Some(dragging) = self.window_state.dragging.as_ref()
+            && dragging.id == id
+        {
+            // Store the pending drag paint info - actual painting happens after tree traversal
+            self.pending_drag_paint = Some(PendingDragPaint {
+                id,
+                base_transform: self.transform,
+            });
         }
 
         self.restore();
diff --git a/src/platform/context_menu.rs b/src/platform/context_menu.rs
index 540fd72e7..5b8fdb43f 100644
--- a/src/platform/context_menu.rs
+++ b/src/platform/context_menu.rs
@@ -204,10 +204,10 @@ pub(crate) fn context_menu_view(
                             move |menu| view_fn(menu, context_menu, on_child_submenu),
                         )
                         .on_event_stop(EventListener::KeyDown, move |event| {
-                            if let Event::Key(KeyboardEvent { key, .. }) = event {
-                                if *key == Key::Named(NamedKey::Escape) {
-                                    context_menu.set(None);
-                                }
+                            if let Event::Key(KeyboardEvent { key, .. }) = event
+                                && *key == Key::Named(NamedKey::Escape)
+                            {
+                                context_menu.set(None);
                             }
                         })
                         .on_event_stop(EventListener::PointerEnter, move |_| {
@@ -285,10 +285,10 @@ pub(crate) fn context_menu_view(
     })
     .on_event_stop(EventListener::PointerMove, move |_| {})
     .on_event_stop(EventListener::KeyDown, move |event| {
-        if let Event::Key(KeyboardEvent { key, .. }) = event {
-            if *key == Key::Named(NamedKey::Escape) {
-                context_menu.set(None);
-            }
+        if let Event::Key(KeyboardEvent { key, .. }) = event
+            && *key == Key::Named(NamedKey::Escape)
+        {
+            context_menu.set(None);
         }
     })
     .style(move |s| {
diff --git a/src/style/cache.rs b/src/style/cache.rs
index 49fd5a568..44242c772 100644
--- a/src/style/cache.rs
+++ b/src/style/cache.rs
@@ -263,11 +263,11 @@ impl StyleCache {
     ) -> Option<(Rc<Style>, bool)> {
         self.clock += 1;
 
-        if let Some(bucket) = self.cache.get_mut(key) {
-            if let Some(result) = bucket.find(parent_style, self.clock) {
-                self.stats.hits += 1;
-                return Some(result);
-            }
+        if let Some(bucket) = self.cache.get_mut(key)
+            && let Some(result) = bucket.find(parent_style, self.clock)
+        {
+            self.stats.hits += 1;
+            return Some(result);
         }
 
         self.stats.misses += 1;
@@ -364,21 +364,21 @@ impl StyleCache {
         let mut removed = 0;
 
         for (key, _, _) in all_entries.into_iter().take(to_remove) {
-            if let Some(bucket) = self.cache.get_mut(&key) {
-                if !bucket.is_empty() {
-                    // Remove oldest entry in this bucket
-                    let oldest_idx = bucket
-                        .entries
-                        .iter()
-                        .enumerate()
-                        .min_by_key(|(_, e)| e.last_access)
-                        .map(|(i, _)| i);
-
-                    if let Some(idx) = oldest_idx {
-                        bucket.entries.remove(idx);
-                        removed += 1;
-                        self.stats.evictions += 1;
-                    }
+            if let Some(bucket) = self.cache.get_mut(&key)
+                && !bucket.is_empty()
+            {
+                // Remove oldest entry in this bucket
+                let oldest_idx = bucket
+                    .entries
+                    .iter()
+                    .enumerate()
+                    .min_by_key(|(_, e)| e.last_access)
+                    .map(|(i, _)| i);
+
+                if let Some(idx) = oldest_idx {
+                    bucket.entries.remove(idx);
+                    removed += 1;
+                    self.stats.evictions += 1;
                 }
             }
         }
@@ -521,27 +521,28 @@ impl Style {
 
         // Compare only inherited properties
         for (key, value) in self.map.iter() {
-            if let StyleKeyInfo::Prop(prop_info) = key.info {
-                if prop_info.inherited {
-                    // Check if other has this property with equal value
-                    if let Some(other_value) = other.map.get(key) {
-                        if !(prop_info.eq_any)(value.as_ref(), other_value.as_ref()) {
-                            return false;
-                        }
-                    } else {
-                        // Other doesn't have this inherited property
+            if let StyleKeyInfo::Prop(prop_info) = key.info
+                && prop_info.inherited
+            {
+                // Check if other has this property with equal value
+                if let Some(other_value) = other.map.get(key) {
+                    if !(prop_info.eq_any)(value.as_ref(), other_value.as_ref()) {
                         return false;
                     }
+                } else {
+                    // Other doesn't have this inherited property
+                    return false;
                 }
             }
         }
 
         // Check if other has inherited properties we don't have
         for (key, _) in other.map.iter() {
-            if let StyleKeyInfo::Prop(prop_info) = key.info {
-                if prop_info.inherited && !self.map.contains_key(key) {
-                    return false;
-                }
+            if let StyleKeyInfo::Prop(prop_info) = key.info
+                && prop_info.inherited
+                && !self.map.contains_key(key)
+            {
+                return false;
             }
         }
 
diff --git a/src/style/mod.rs b/src/style/mod.rs
index a8ce4aff2..c5d026a6a 100644
--- a/src/style/mod.rs
+++ b/src/style/mod.rs
@@ -712,10 +712,10 @@ impl Style {
                 self.apply_mut(map.apply_selectors(selectors));
             }
         }
-        if self.get(Selected) {
-            if let Some(map) = self.get_nested_map(StyleSelector::Selected.to_key()) {
-                self.apply_mut(map.apply_selectors(&[StyleSelector::Selected]));
-            }
+        if self.get(Selected)
+            && let Some(map) = self.get_nested_map(StyleSelector::Selected.to_key())
+        {
+            self.apply_mut(map.apply_selectors(&[StyleSelector::Selected]));
         }
         self
     }
diff --git a/src/style/transition.rs b/src/style/transition.rs
index e9c47ddbd..655105f6a 100644
--- a/src/style/transition.rs
+++ b/src/style/transition.rs
@@ -66,16 +66,16 @@ impl<T: StylePropValue> TransitionState<T> {
             if let Some(transition) = &self.transition {
                 let time = now.saturating_duration_since(active.start);
                 let time_percent = time.as_secs_f64() / transition.duration.as_secs_f64();
-                if time < transition.duration || !transition.easing.finished(time_percent) {
-                    if let Some(i) = T::interpolate(
+                if (time < transition.duration || !transition.easing.finished(time_percent))
+                    && let Some(i) = T::interpolate(
                         &active.before,
                         &active.after,
                         transition.easing.eval(time_percent),
-                    ) {
-                        active.current = i;
-                        *request_transition = true;
-                        return true;
-                    }
+                    )
+                {
+                    active.current = i;
+                    *request_transition = true;
+                    return true;
                 }
             }
             // time has past duration, or the value is not interpolatable
diff --git a/src/view/id.rs b/src/view/id.rs
index 143b64a11..70c1af748 100644
--- a/src/view/id.rs
+++ b/src/view/id.rs
@@ -85,10 +85,10 @@ impl ViewId {
             // Remove from overlays if registered
             s.overlays.remove(*self);
             // Remove self from parent's children list
-            if let Some(Some(parent)) = s.parent.get(*self) {
-                if let Some(children) = s.children.get_mut(*parent) {
-                    children.retain(|c| c != self);
-                }
+            if let Some(Some(parent)) = s.parent.get(*self)
+                && let Some(children) = s.children.get_mut(*parent)
+            {
+                children.retain(|c| c != self);
             }
             // Clean up all SecondaryMap entries for this view to prevent
             // stale data when slots are reused. SecondaryMaps don't auto-clean
@@ -357,11 +357,11 @@ impl ViewId {
             // root_view_id() always returns SOMETHING.  If the view is not yet added
             // to a window, it can be itself or its nearest ancestor, which means we
             // will store garbage permanently.
-            if let Some(root) = root_view_id {
-                if is_known_root(&root) {
-                    s.root.insert(*self, root_view_id);
-                    return Some(root);
-                }
+            if let Some(root) = root_view_id
+                && is_known_root(&root)
+            {
+                s.root.insert(*self, root_view_id);
+                return Some(root);
             }
             None
         })
@@ -1103,14 +1103,14 @@ pub fn process_pending_scope_reparents() {
             let child_scope = child_id.scope();
             if let Some(child_scope) = child_scope {
                 // Try to find a parent scope by walking up from the parent
-                if let Some(parent_id) = child_id.parent() {
-                    if let Some(parent_scope) = parent_id.find_scope() {
-                        // Guard: Don't create a cycle if same scope is on both views
-                        if child_scope != parent_scope {
-                            child_scope.set_parent(parent_scope);
-                        }
-                        return false; // Successfully handled, remove from pending
+                if let Some(parent_id) = child_id.parent()
+                    && let Some(parent_scope) = parent_id.find_scope()
+                {
+                    // Guard: Don't create a cycle if same scope is on both views
+                    if child_scope != parent_scope {
+                        child_scope.set_parent(parent_scope);
                     }
+                    return false; // Successfully handled, remove from pending
                 }
                 true // Still pending, keep in the set
             } else {
diff --git a/src/views/decorator.rs b/src/views/decorator.rs
index 29240ab60..fc40b52c3 100644
--- a/src/views/decorator.rs
+++ b/src/views/decorator.rs
@@ -251,11 +251,11 @@ pub trait Decorators: IntoView {
                 modifiers,
                 ..
             }) = e
+                && *event_key == key
+                && cmp(*modifiers)
             {
-                if *event_key == key && cmp(*modifiers) {
-                    action(e);
-                    return EventPropagation::Stop;
-                }
+                action(e);
+                return EventPropagation::Stop;
             }
             EventPropagation::Continue
         })
@@ -277,11 +277,11 @@ pub trait Decorators: IntoView {
                 modifiers,
                 ..
             }) = e
+                && *event_key == key
+                && cmp(*modifiers)
             {
-                if *event_key == key && cmp(*modifiers) {
-                    action(e);
-                    return EventPropagation::Stop;
-                }
+                action(e);
+                return EventPropagation::Stop;
             }
             EventPropagation::Continue
         })
diff --git a/src/views/drag_window_area.rs b/src/views/drag_window_area.rs
index b521e94d0..087d98490 100644
--- a/src/views/drag_window_area.rs
+++ b/src/views/drag_window_area.rs
@@ -22,10 +22,10 @@ pub fn drag_window_area<V: IntoView + 'static>(child: V) -> DragWindowArea {
     id.set_children([child]);
     DragWindowArea { id }
         .on_event_stop(EventListener::PointerDown, |e| {
-            if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { button, .. })) = e {
-                if button.is_some_and(|b| b == PointerButton::Primary) {
-                    drag_window();
-                }
+            if let Event::Pointer(PointerEvent::Down(PointerButtonEvent { button, .. })) = e
+                && button.is_some_and(|b| b == PointerButton::Primary)
+            {
+                drag_window();
             }
         })
         .on_double_click_stop(|_| toggle_window_maximized())
diff --git a/src/views/dyn_stack.rs b/src/views/dyn_stack.rs
index 9a60e2853..b3a4397b7 100644
--- a/src/views/dyn_stack.rs
+++ b/src/views/dyn_stack.rs
@@ -227,12 +227,12 @@ pub(crate) fn diff<K: Eq + Hash, V>(from: &FxIndexSet<K>, to: &FxIndexSet<K>) ->
     let mut removed_idx = removed.next().map(|k| from.get_full(k).unwrap().0);
 
     for (idx, k) in to.iter().enumerate() {
-        if let Some(added_idx) = added_idx.as_mut().filter(|r_i| **r_i == idx) {
-            if let Some(next_added) = added.next().map(|k| to.get_full(k).unwrap().0) {
-                *added_idx = next_added;
+        if let Some(added_idx) = added_idx.as_mut().filter(|r_i| **r_i == idx)
+            && let Some(next_added) = added.next().map(|k| to.get_full(k).unwrap().0)
+        {
+            *added_idx = next_added;
 
-                normalized_idx = usize::wrapping_sub(normalized_idx, 1);
-            }
+            normalized_idx = usize::wrapping_sub(normalized_idx, 1);
         }
 
         if let Some(removed_idx) = removed_idx.as_mut().filter(|r_i| **r_i == idx) {
@@ -243,13 +243,13 @@ pub(crate) fn diff<K: Eq + Hash, V>(from: &FxIndexSet<K>, to: &FxIndexSet<K>) ->
             }
         }
 
-        if let Some((from_idx, _)) = from.get_full(k) {
-            if from_idx != normalized_idx || from_idx != idx {
-                move_cmds.push(DiffOpMove {
-                    from: from_idx,
-                    to: idx,
-                });
-            }
+        if let Some((from_idx, _)) = from.get_full(k)
+            && (from_idx != normalized_idx || from_idx != idx)
+        {
+            move_cmds.push(DiffOpMove {
+                from: from_idx,
+                to: idx,
+            });
         }
 
         normalized_idx = normalized_idx.wrapping_add(1);
diff --git a/src/views/editor/actions.rs b/src/views/editor/actions.rs
index df1d23f6f..b2f581244 100644
--- a/src/views/editor/actions.rs
+++ b/src/views/editor/actions.rs
@@ -58,10 +58,8 @@ fn handle_edit_command_default(
     // be more flexible.
     let had_edits = action.do_edit(ed, &mut cursor, cmd, modal, &mut register, smart_tab);
 
-    if had_edits {
-        if let Some(data) = yank_data {
-            register.add_delete(data);
-        }
+    if had_edits && let Some(data) = yank_data {
+        register.add_delete(data);
     }
 
     ed.cursor.set(cursor);
diff --git a/src/views/editor/movement.rs b/src/views/editor/movement.rs
index edc80dc20..7443e25f3 100644
--- a/src/views/editor/movement.rs
+++ b/src/views/editor/movement.rs
@@ -238,15 +238,15 @@ fn move_left(
     let rope_text = ed.rope_text();
     let mut new_offset = rope_text.move_left(offset, mode, count);
 
-    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(ed, offset) {
-        if soft_tab_width > 1 {
-            new_offset = snap_to_soft_tab(
-                rope_text.text(),
-                new_offset,
-                SnapDirection::Left,
-                soft_tab_width,
-            );
-        }
+    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(ed, offset)
+        && soft_tab_width > 1
+    {
+        new_offset = snap_to_soft_tab(
+            rope_text.text(),
+            new_offset,
+            SnapDirection::Left,
+            soft_tab_width,
+        );
     }
 
     *affinity = CursorAffinity::Forward;
@@ -266,15 +266,15 @@ fn move_right(
     let rope_text = view.rope_text();
     let mut new_offset = rope_text.move_right(offset, mode, count);
 
-    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(view, offset) {
-        if soft_tab_width > 1 {
-            new_offset = snap_to_soft_tab(
-                rope_text.text(),
-                new_offset,
-                SnapDirection::Right,
-                soft_tab_width,
-            );
-        }
+    if let Some(soft_tab_width) = atomic_soft_tab_width_for_offset(view, offset)
+        && soft_tab_width > 1
+    {
+        new_offset = snap_to_soft_tab(
+            rope_text.text(),
+            new_offset,
+            SnapDirection::Right,
+            soft_tab_width,
+        );
     }
 
     *affinity = CursorAffinity::Backward;
diff --git a/src/views/editor/text_document.rs b/src/views/editor/text_document.rs
index 9ff8e09f8..1a7c0e5f0 100644
--- a/src/views/editor/text_document.rs
+++ b/src/views/editor/text_document.rs
@@ -247,19 +247,18 @@ impl DocumentPhantom for TextDocument {
 
         if self.buffer.with_untracked(Buffer::is_empty)
             && self.preedit.preedit.with_untracked(|p| p.is_none())
+            && let Some(placeholder) = self.placeholder(edid)
         {
-            if let Some(placeholder) = self.placeholder(edid) {
-                text.push(PhantomText {
-                    kind: PhantomTextKind::Placeholder,
-                    col: 0,
-                    affinity: None,
-                    text: placeholder,
-                    font_size: None,
-                    fg: Some(styling.placeholder_color()),
-                    bg: None,
-                    under_line: None,
-                });
-            }
+            text.push(PhantomText {
+                kind: PhantomTextKind::Placeholder,
+                col: 0,
+                affinity: None,
+                text: placeholder,
+                font_size: None,
+                fg: Some(styling.placeholder_color()),
+                bg: None,
+                under_line: None,
+            });
         }
 
         if let Some(preedit) = self.preedit_phantom(Some(styling.preedit_underline_color()), line) {
diff --git a/src/views/editor/view.rs b/src/views/editor/view.rs
index 0e8812069..d3b43015c 100644
--- a/src/views/editor/view.rs
+++ b/src/views/editor/view.rs
@@ -1286,10 +1286,10 @@ fn editor_content(
                 #[cfg(target_os = "macos")]
                 mods.set(Modifiers::ALT, false);
 
-                if mods.is_empty() {
-                    if let Key::Character(c) = &key_event.key {
-                        editor.get_untracked().receive_char(c);
-                    }
+                if mods.is_empty()
+                    && let Key::Character(c) = &key_event.key
+                {
+                    editor.get_untracked().receive_char(c);
                 }
             })
             .style(|s| s.min_size_full())
diff --git a/src/views/editor/visual_line.rs b/src/views/editor/visual_line.rs
index 76fc27d86..2f9c51fac 100644
--- a/src/views/editor/visual_line.rs
+++ b/src/views/editor/visual_line.rs
@@ -1039,16 +1039,16 @@ fn find_vline_of_offset(
             .map(|line_index| (VLine(vline.get() + line_index), line_index))?;
 
     // If the most recent line break was due to a soft line break,
-    if line_index > 0 {
-        if let CursorAffinity::Backward = affinity {
-            // TODO: This can definitely be smarter. We're doing a vline search, and then this is
-            // practically doing another!
-            let line_end = lines.offset_of_vline(text_prov, vline);
-            // then if we're right at that soft line break, a backwards affinity
-            // means that we are on the previous visual line.
-            if line_end == offset && vline.get() != 0 {
-                return Some((VLine(vline.get() - 1), line_index - 1));
-            }
+    if line_index > 0
+        && let CursorAffinity::Backward = affinity
+    {
+        // TODO: This can definitely be smarter. We're doing a vline search, and then this is
+        // practically doing another!
+        let line_end = lines.offset_of_vline(text_prov, vline);
+        // then if we're right at that soft line break, a backwards affinity
+        // means that we are on the previous visual line.
+        if line_end == offset && vline.get() != 0 {
+            return Some((VLine(vline.get() - 1), line_index - 1));
         }
     }
 
@@ -1080,23 +1080,23 @@ fn find_rvline_of_offset(
         .map(|line_index| RVLine::new(buffer_line, line_index))?;
 
     // If the most recent line break was due to a soft line break,
-    if rv.line_index > 0 {
-        if let CursorAffinity::Backward = affinity {
-            let line_end = lines.offset_of_rvline(text_prov, rv);
-            // then if we're right at that soft line break, a backwards affinity
-            // means that we are on the previous visual line.
-            if line_end == offset {
-                if rv.line_index > 0 {
-                    return Some(RVLine::new(rv.line, rv.line_index - 1));
-                } else if rv.line == 0 {
-                    // There is no previous line, we do nothing.
-                } else {
-                    // We have to get rvline info for that rvline, so we can get the last line index
-                    // This should always have at least one rvline in it.
-                    let font_sizes = lines.font_sizes.borrow();
-                    let (prev, _) = prev_rvline(&layouts, text_prov, &**font_sizes, rv)?;
-                    return Some(prev);
-                }
+    if rv.line_index > 0
+        && let CursorAffinity::Backward = affinity
+    {
+        let line_end = lines.offset_of_rvline(text_prov, rv);
+        // then if we're right at that soft line break, a backwards affinity
+        // means that we are on the previous visual line.
+        if line_end == offset {
+            if rv.line_index > 0 {
+                return Some(RVLine::new(rv.line, rv.line_index - 1));
+            } else if rv.line == 0 {
+                // There is no previous line, we do nothing.
+            } else {
+                // We have to get rvline info for that rvline, so we can get the last line index
+                // This should always have at least one rvline in it.
+                let font_sizes = lines.font_sizes.borrow();
+                let (prev, _) = prev_rvline(&layouts, text_prov, &**font_sizes, rv)?;
+                return Some(prev);
             }
         }
     }
diff --git a/src/views/label.rs b/src/views/label.rs
index 829cdf52a..a993b8ab2 100644
--- a/src/views/label.rs
+++ b/src/views/label.rs
@@ -269,15 +269,15 @@ impl Label {
     fn handle_modifier_cmd(&mut self, command: &TextCommand) -> bool {
         match command {
             TextCommand::Copy => {
-                if let Some((start_c, end_c)) = &self.selection_range {
-                    if let Some(ref text_layout) = self.text_layout {
-                        let start_line_idx = text_layout.lines_range()[start_c.line].start;
-                        let end_line_idx = text_layout.lines_range()[end_c.line].start;
-                        let start_idx = start_line_idx + start_c.index;
-                        let end_idx = end_line_idx + end_c.index;
-                        let selection_txt = self.label[start_idx..end_idx].into();
-                        let _ = Clipboard::set_contents(selection_txt);
-                    }
+                if let Some((start_c, end_c)) = &self.selection_range
+                    && let Some(ref text_layout) = self.text_layout
+                {
+                    let start_line_idx = text_layout.lines_range()[start_c.line].start;
+                    let end_line_idx = text_layout.lines_range()[end_c.line].start;
+                    let start_idx = start_line_idx + start_c.index;
+                    let end_idx = end_line_idx + end_c.index;
+                    let selection_txt = self.label[start_idx..end_idx].into();
+                    let _ = Clipboard::set_contents(selection_txt);
                 }
                 true
             }
@@ -436,10 +436,10 @@ impl View for Label {
                 let width = size.width.ceil() as f32;
                 let mut height = size.height as f32;
 
-                if self.style.text_overflow() == TextOverflow::Wrap {
-                    if let Some(t) = self.available_text_layout.as_ref() {
-                        height = height.max(t.size().height as f32);
-                    }
+                if self.style.text_overflow() == TextOverflow::Wrap
+                    && let Some(t) = self.available_text_layout.as_ref()
+                {
+                    height = height.max(t.size().height as f32);
                 }
 
                 (width, height)
diff --git a/src/views/scroll.rs b/src/views/scroll.rs
index fc62d4fbc..eace78b6e 100644
--- a/src/views/scroll.rs
+++ b/src/views/scroll.rs
@@ -603,10 +603,10 @@ impl Scroll {
             let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
             let rect = rect.to_rounded_rect(radius(style, rect, true));
             cx.fill(&rect, &style.color().unwrap_or(HANDLE_COLOR), 0.0);
-            if edge_width > 0.0 {
-                if let Some(color) = style.border_color().right {
-                    cx.stroke(&rect, &color, &Stroke::new(edge_width));
-                }
+            if edge_width > 0.0
+                && let Some(color) = style.border_color().right
+            {
+                cx.stroke(&rect, &color, &Stroke::new(edge_width));
             }
         }
 
@@ -630,10 +630,10 @@ impl Scroll {
             let rect = (bounds - scroll_offset).inset(-edge_width / 2.0);
             let rect = rect.to_rounded_rect(radius(style, rect, false));
             cx.fill(&rect, &style.color().unwrap_or(HANDLE_COLOR), 0.0);
-            if edge_width > 0.0 {
-                if let Some(color) = style.border_color().right {
-                    cx.stroke(&rect, &color, &Stroke::new(edge_width));
-                }
+            if edge_width > 0.0
+                && let Some(color) = style.border_color().right
+            {
+                cx.stroke(&rect, &color, &Stroke::new(edge_width));
             }
         }
     }
@@ -930,10 +930,10 @@ impl View for Scroll {
         let old_child_size = self.child_size;
         self.update_size();
         // Call callback if child size changed
-        if old_child_size != self.child_size {
-            if let Some(callback) = &self.on_child_size {
-                callback(self.child_size);
-            }
+        if old_child_size != self.child_size
+            && let Some(callback) = &self.on_child_size
+        {
+            callback(self.child_size);
         }
         self.clamp_child_viewport(cx.window_state, self.child_viewport);
         self.computed_child_viewport = self.child_viewport;
@@ -1066,14 +1066,13 @@ impl View for Scroll {
         event: &Event,
     ) -> EventPropagation {
         if let Event::Pointer(PointerEvent::Scroll(PointerScrollEvent { state, .. })) = &event {
-            if let Some(listener) = event.listener() {
-                if self
+            if let Some(listener) = event.listener()
+                && self
                     .id
                     .apply_event(&listener, event)
                     .is_some_and(|prop| prop.is_processed())
-                {
-                    return EventPropagation::Stop;
-                }
+            {
+                return EventPropagation::Stop;
             }
             if let Some(delta) = event.pixel_scroll_delta_vec2() {
                 let delta = -if self.scroll_style.vertical_scroll_as_horizontal()
diff --git a/src/views/svg.rs b/src/views/svg.rs
index 2694d8a11..192e432c7 100644
--- a/src/views/svg.rs
+++ b/src/views/svg.rs
@@ -145,11 +145,11 @@ impl View for Svg {
                 self.id.request_style();
             }
         }
-        if let Some(prop_reader) = &mut self.css_prop {
-            if prop_reader.read_custom(cx) {
-                self.id
-                    .update_state(SvgOrStyle::Style(prop_reader.css_string()));
-            }
+        if let Some(prop_reader) = &mut self.css_prop
+            && prop_reader.read_custom(cx)
+        {
+            self.id
+                .update_state(SvgOrStyle::Style(prop_reader.css_string()));
         }
     }
 
diff --git a/src/views/tab.rs b/src/views/tab.rs
index d6475753e..289fd8d56 100644
--- a/src/views/tab.rs
+++ b/src/views/tab.rs
@@ -291,14 +291,13 @@ impl<T> View for Tab<T> {
     }
 
     fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        if let Some(active_tab) = self.active {
-            if let Some(Some((active, _))) = self
+        if let Some(active_tab) = self.active
+            && let Some(Some((active, _))) = self
                 .children
                 .get(active_tab)
                 .or_else(|| self.children.first())
-            {
-                cx.paint_view(*active);
-            }
+        {
+            cx.paint_view(*active);
         }
     }
 }
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index 6c452d957..8bec889c5 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -1105,10 +1105,10 @@ fn get_dbl_click_selection(glyph_idx: usize, buffer: &str) -> Range<usize> {
     }
 
     // left-over non-alphanumeric char sequence at the end of the buffer(after the last word)
-    if let Some(last) = selectable_ranges.last() {
-        if last.end != buffer.len() {
-            selectable_ranges.push(last.end..buffer.len());
-        }
+    if let Some(last) = selectable_ranges.last()
+        && last.end != buffer.len()
+    {
+        selectable_ranges.push(last.end..buffer.len());
     }
 
     for range in selectable_ranges {
diff --git a/src/views/toggle_button.rs b/src/views/toggle_button.rs
index 6f711a07c..a62dfebea 100644
--- a/src/views/toggle_button.rs
+++ b/src/views/toggle_button.rs
@@ -218,10 +218,10 @@ impl View for ToggleButton {
                 key,
                 ..
             }) => {
-                if *key == Key::Named(NamedKey::Enter) {
-                    if let Some(ontoggle) = &self.ontoggle {
-                        ontoggle(!self.state);
-                    }
+                if *key == Key::Named(NamedKey::Enter)
+                    && let Some(ontoggle) = &self.ontoggle
+                {
+                    ontoggle(!self.state);
                 }
             }
             _ => {}
diff --git a/src/views/tooltip.rs b/src/views/tooltip.rs
index b56f9bcb7..3c0881a64 100644
--- a/src/views/tooltip.rs
+++ b/src/views/tooltip.rs
@@ -82,22 +82,20 @@ impl View for Tooltip {
     }
 
     fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn std::any::Any>) {
-        if let Ok(token) = state.downcast::<TimerToken>() {
-            if let Some(window_origin) = self.window_origin {
-                if self.hover.map(|(_, t)| t) == Some(*token) {
-                    let tip = self.tip.clone();
-
-                    let point = window_origin
-                        + self.hover.unwrap().0.to_vec2()
-                        + (10. / self.scale, 10. / self.scale);
-                    let overlay_id = add_overlay(
-                        ToolTipOverlay::new(tip())
-                            .style(move |s| s.inset_left(point.x).inset_top(point.y)),
-                    );
-                    overlay_id.set_style_parent(self.id);
-                    *self.overlay.borrow_mut() = Some(overlay_id);
-                }
-            }
+        if let Ok(token) = state.downcast::<TimerToken>()
+            && let Some(window_origin) = self.window_origin
+            && self.hover.map(|(_, t)| t) == Some(*token)
+        {
+            let tip = self.tip.clone();
+
+            let point = window_origin
+                + self.hover.unwrap().0.to_vec2()
+                + (10. / self.scale, 10. / self.scale);
+            let overlay_id = add_overlay(
+                ToolTipOverlay::new(tip()).style(move |s| s.inset_left(point.x).inset_top(point.y)),
+            );
+            overlay_id.set_style_parent(self.id);
+            *self.overlay.borrow_mut() = Some(overlay_id);
         }
     }
 
diff --git a/src/views/value_container.rs b/src/views/value_container.rs
index b7d2011e1..5b9af79cd 100644
--- a/src/views/value_container.rs
+++ b/src/views/value_container.rs
@@ -74,10 +74,10 @@ impl<T: 'static> View for ValueContainer<T> {
     }
 
     fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn Any>) {
-        if let Ok(state) = state.downcast::<T>() {
-            if let Some(on_update) = self.on_update.as_ref() {
-                on_update(*state);
-            }
+        if let Ok(state) = state.downcast::<T>()
+            && let Some(on_update) = self.on_update.as_ref()
+        {
+            on_update(*state);
         }
     }
 }
diff --git a/src/views/virtual_stack.rs b/src/views/virtual_stack.rs
index fd9239f35..eae1db453 100644
--- a/src/views/virtual_stack.rs
+++ b/src/views/virtual_stack.rs
@@ -403,13 +403,13 @@ impl<T> View for VirtualStack<T> {
                 );
                 self.id.request_all();
             }
-        } else if state.is::<usize>() {
-            if let Ok(idx) = state.downcast::<usize>() {
-                self.id.request_style_recursive();
-                self.scroll_to_idx(*idx);
-                self.selected_idx.clear();
-                self.selected_idx.insert(*idx);
-            }
+        } else if state.is::<usize>()
+            && let Ok(idx) = state.downcast::<usize>()
+        {
+            self.id.request_style_recursive();
+            self.scroll_to_idx(*idx);
+            self.selected_idx.clear();
+            self.selected_idx.insert(*idx);
         }
     }
 
diff --git a/src/window/handle.rs b/src/window/handle.rs
index b7a562802..95a7e7a7b 100644
--- a/src/window/handle.rs
+++ b/src/window/handle.rs
@@ -1239,15 +1239,15 @@ impl WindowHandle {
     pub(crate) fn set_menu_theme_for_windows(&self, theme: winit::window::Theme) {
         use raw_window_handle::{HasWindowHandle, RawWindowHandle};
 
-        if let RawWindowHandle::Win32(handle) = self.window.window_handle().unwrap().as_raw() {
-            if let Some(menu) = &self.window_menu {
-                unsafe {
-                    let menu_theme = match theme {
-                        winit::window::Theme::Light => MudaMenuTheme::Light,
-                        winit::window::Theme::Dark => MudaMenuTheme::Dark,
-                    };
-                    let _ = menu.set_theme_for_hwnd(handle.hwnd.into(), menu_theme);
-                }
+        if let RawWindowHandle::Win32(handle) = self.window.window_handle().unwrap().as_raw()
+            && let Some(menu) = &self.window_menu
+        {
+            unsafe {
+                let menu_theme = match theme {
+                    winit::window::Theme::Light => MudaMenuTheme::Light,
+                    winit::window::Theme::Dark => MudaMenuTheme::Dark,
+                };
+                let _ = menu.set_theme_for_hwnd(handle.hwnd.into(), menu_theme);
             }
         }
     }