Add assert messages and print bad argument values in asserts (#5216)

Enabled the `missing_assert_message` lint

* [x] I have followed the instructions in the PR template

---------

Co-authored-by: Lucas Meurer <[email protected]>

Author: bircni

Cargo.toml

@@ -207,6 +207,7 @@ match_wild_err_arm = "warn"
 match_wildcard_for_single_variants = "warn"
 mem_forget = "warn"
 mismatching_type_param_order = "warn"
+missing_assert_message = "warn"
 missing_enforced_import_renames = "warn"
 missing_errors_doc = "warn"
 missing_safety_doc = "warn"
@@ -274,7 +275,6 @@ zero_sized_map_values = "warn"
 
 # TODO(emilk): maybe enable more of these lints?
 iter_over_hash_type = "allow"
-missing_assert_message = "allow"
 should_panic_without_expect = "allow"
 too_many_lines = "allow"
 unwrap_used = "allow"                 # TODO(emilk): We really wanna warn on this one

crates/ecolor/src/color32.rs

@@ -273,7 +273,10 @@ impl Color32 {
     /// This is perceptually even, and faster that [`Self::linear_multiply`].
     #[inline]
     pub fn gamma_multiply(self, factor: f32) -> Self {
-        debug_assert!(0.0 <= factor && factor.is_finite());
+        debug_assert!(
+            0.0 <= factor && factor.is_finite(),
+            "factor should be finite, but was {factor}"
+        );
         let Self([r, g, b, a]) = self;
         Self([
             (r as f32 * factor + 0.5) as u8,
@@ -306,7 +309,10 @@ impl Color32 {
     /// You likely want to use [`Self::gamma_multiply`] instead.
     #[inline]
     pub fn linear_multiply(self, factor: f32) -> Self {
-        debug_assert!(0.0 <= factor && factor.is_finite());
+        debug_assert!(
+            0.0 <= factor && factor.is_finite(),
+            "factor should be finite, but was {factor}"
+        );
         // As an unfortunate side-effect of using premultiplied alpha
         // we need a somewhat expensive conversion to linear space and back.
         Rgba::from(self).multiply(factor).into()

crates/ecolor/src/rgba.rs

@@ -90,15 +90,24 @@ impl Rgba {
 
     #[inline]
     pub fn from_luminance_alpha(l: f32, a: f32) -> Self {
-        debug_assert!(0.0 <= l && l <= 1.0);
-        debug_assert!(0.0 <= a && a <= 1.0);
+        debug_assert!(
+            0.0 <= l && l <= 1.0,
+            "l should be in the range [0, 1], but was {l}"
+        );
+        debug_assert!(
+            0.0 <= a && a <= 1.0,
+            "a should be in the range [0, 1], but was {a}"
+        );
         Self([l * a, l * a, l * a, a])
     }
 
     /// Transparent black
     #[inline]
     pub fn from_black_alpha(a: f32) -> Self {
-        debug_assert!(0.0 <= a && a <= 1.0);
+        debug_assert!(
+            0.0 <= a && a <= 1.0,
+            "a should be in the range [0, 1], but was {a}"
+        );
         Self([0.0, 0.0, 0.0, a])
     }
 

crates/eframe/src/stopwatch.rs

@@ -18,7 +18,7 @@ impl Stopwatch {
     }
 
     pub fn start(&mut self) {
-        assert!(self.start.is_none());
+        assert!(self.start.is_none(), "Stopwatch already running");
         self.start = Some(Instant::now());
     }
 
@@ -29,7 +29,7 @@ impl Stopwatch {
     }
 
     pub fn resume(&mut self) {
-        assert!(self.start.is_none());
+        assert!(self.start.is_none(), "Stopwatch still running");
         self.start = Some(Instant::now());
     }
 

crates/egui/src/containers/menu.rs

@@ -159,7 +159,6 @@ impl MenuState {
 }
 
 /// Horizontal menu bar where you can add [`MenuButton`]s.
-
 /// The menu bar goes well in a [`crate::TopBottomPanel::top`],
 /// but can also be placed in a [`crate::Window`].
 /// In the latter case you may want to wrap it in [`Frame`].

crates/egui/src/context.rs

@@ -82,7 +82,11 @@ impl Default for WrappedTextureManager {
             epaint::FontImage::new([0, 0]).into(),
             Default::default(),
         );
-        assert_eq!(font_id, TextureId::default());
+        assert_eq!(
+            font_id,
+            TextureId::default(),
+            "font id should be equal to TextureId::default(), but was {font_id:?}",
+        );
 
         Self(Arc::new(RwLock::new(tex_mngr)))
     }
@@ -804,7 +808,11 @@ impl Context {
         let max_passes = self.write(|ctx| ctx.memory.options.max_passes.get());
 
         let mut output = FullOutput::default();
-        debug_assert_eq!(output.platform_output.num_completed_passes, 0);
+        debug_assert_eq!(
+            output.platform_output.num_completed_passes, 0,
+            "output must be fresh, but had {} passes",
+            output.platform_output.num_completed_passes
+        );
 
         loop {
             profiling::scope!(
@@ -828,7 +836,11 @@ impl Context {
             self.begin_pass(new_input.take());
             run_ui(self);
             output.append(self.end_pass());
-            debug_assert!(0 < output.platform_output.num_completed_passes);
+            debug_assert!(
+                0 < output.platform_output.num_completed_passes,
+                "Completed passes was lower than 0, was {}",
+                output.platform_output.num_completed_passes
+            );
 
             if !output.platform_output.requested_discard() {
                 break; // no need for another pass
@@ -3272,7 +3284,11 @@ impl Context {
         #[cfg(feature = "accesskit")]
         self.pass_state_mut(|fs| {
             if let Some(state) = fs.accesskit_state.as_mut() {
-                assert_eq!(state.parent_stack.pop(), Some(_id));
+                assert_eq!(
+                    state.parent_stack.pop(),
+                    Some(_id),
+                    "Mismatched push/pop in with_accessibility_parent"
+                );
             }
         });
 

crates/egui/src/hit_test.rs

@@ -175,11 +175,17 @@ pub fn hit_test(
             restore_widget_rect(wr);
         }
         if let Some(wr) = &mut hits.drag {
-            debug_assert!(wr.sense.senses_drag());
+            debug_assert!(
+                wr.sense.senses_drag(),
+                "We should only return drag hits if they sense drag"
+            );
             restore_widget_rect(wr);
         }
         if let Some(wr) = &mut hits.click {
-            debug_assert!(wr.sense.senses_click());
+            debug_assert!(
+                wr.sense.senses_click(),
+                "We should only return click hits if they sense click"
+            );
             restore_widget_rect(wr);
         }
     }

crates/egui/src/layout.rs

@@ -71,9 +71,17 @@ impl Region {
     }
 
     pub fn sanity_check(&self) {
-        debug_assert!(!self.min_rect.any_nan());
-        debug_assert!(!self.max_rect.any_nan());
-        debug_assert!(!self.cursor.any_nan());
+        debug_assert!(
+            !self.min_rect.any_nan(),
+            "min rect has Nan: {:?}",
+            self.min_rect
+        );
+        debug_assert!(
+            !self.max_rect.any_nan(),
+            "max rect has Nan: {:?}",
+            self.max_rect
+        );
+        debug_assert!(!self.cursor.any_nan(), "cursor has Nan: {:?}", self.cursor);
     }
 }
 
@@ -394,8 +402,8 @@ impl Layout {
 /// ## Doing layout
 impl Layout {
     pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect {
-        debug_assert!(size.x >= 0.0 && size.y >= 0.0);
-        debug_assert!(!outer.is_negative());
+        debug_assert!(size.x >= 0.0 && size.y >= 0.0, "Negative size: {size:?}");
+        debug_assert!(!outer.is_negative(), "Negative outer: {outer:?}");
         self.align2().align_size_within_rect(size, outer).round_ui()
     }
 
@@ -421,7 +429,7 @@ impl Layout {
     }
 
     pub(crate) fn region_from_max_rect(&self, max_rect: Rect) -> Region {
-        debug_assert!(!max_rect.any_nan());
+        debug_assert!(!max_rect.any_nan(), "max_rect is not NaN: {max_rect:?}");
         let mut region = Region {
             min_rect: Rect::NOTHING, // temporary
             max_rect,
@@ -454,8 +462,8 @@ impl Layout {
     /// Given the cursor in the region, how much space is available
     /// for the next widget?
     fn available_from_cursor_max_rect(&self, cursor: Rect, max_rect: Rect) -> Rect {
-        debug_assert!(!cursor.any_nan());
-        debug_assert!(!max_rect.any_nan());
+        debug_assert!(!cursor.any_nan(), "cursor is NaN: {cursor:?}");
+        debug_assert!(!max_rect.any_nan(), "max_rect is NaN: {max_rect:?}");
 
         // NOTE: in normal top-down layout the cursor has moved below the current max_rect,
         // but the available shouldn't be negative.
@@ -509,7 +517,7 @@ impl Layout {
             avail.max.y = y;
         }
 
-        debug_assert!(!avail.any_nan());
+        debug_assert!(!avail.any_nan(), "avail is NaN: {avail:?}");
 
         avail
     }
@@ -520,7 +528,10 @@ impl Layout {
     /// Use `justify_and_align` to get the inner `widget_rect`.
     pub(crate) fn next_frame(&self, region: &Region, child_size: Vec2, spacing: Vec2) -> Rect {
         region.sanity_check();
-        debug_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+        debug_assert!(
+            child_size.x >= 0.0 && child_size.y >= 0.0,
+            "Negative size: {child_size:?}"
+        );
 
         if self.main_wrap {
             let available_size = self.available_rect_before_wrap(region).size();
@@ -600,7 +611,10 @@ impl Layout {
 
     fn next_frame_ignore_wrap(&self, region: &Region, child_size: Vec2) -> Rect {
         region.sanity_check();
-        debug_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
+        debug_assert!(
+            child_size.x >= 0.0 && child_size.y >= 0.0,
+            "Negative size: {child_size:?}"
+        );
 
         let available_rect = self.available_rect_before_wrap(region);
 
@@ -633,16 +647,19 @@ impl Layout {
             frame_rect = frame_rect.translate(Vec2::Y * (region.cursor.top() - frame_rect.top()));
         }
 
-        debug_assert!(!frame_rect.any_nan());
-        debug_assert!(!frame_rect.is_negative());
+        debug_assert!(!frame_rect.any_nan(), "frame_rect is NaN: {frame_rect:?}");
+        debug_assert!(!frame_rect.is_negative(), "frame_rect is negative");
 
         frame_rect.round_ui()
     }
 
     /// Apply justify (fill width/height) and/or alignment after calling `next_space`.
     pub(crate) fn justify_and_align(&self, frame: Rect, mut child_size: Vec2) -> Rect {
-        debug_assert!(child_size.x >= 0.0 && child_size.y >= 0.0);
-        debug_assert!(!frame.is_negative());
+        debug_assert!(
+            child_size.x >= 0.0 && child_size.y >= 0.0,
+            "Negative size: {child_size:?}"
+        );
+        debug_assert!(!frame.is_negative(), "frame is negative");
 
         if self.horizontal_justify() {
             child_size.x = child_size.x.at_least(frame.width()); // fill full width
@@ -660,8 +677,8 @@ impl Layout {
     ) -> Rect {
         let frame = self.next_frame_ignore_wrap(region, size);
         let rect = self.align_size_within_rect(size, frame);
-        debug_assert!(!rect.any_nan());
-        debug_assert!(!rect.is_negative());
+        debug_assert!(!rect.any_nan(), "rect is NaN: {rect:?}");
+        debug_assert!(!rect.is_negative(), "rect is negative: {rect:?}");
         rect
     }
 
@@ -704,7 +721,7 @@ impl Layout {
         widget_rect: Rect,
         item_spacing: Vec2,
     ) {
-        debug_assert!(!cursor.any_nan());
+        debug_assert!(!cursor.any_nan(), "cursor is NaN: {cursor:?}");
         if self.main_wrap {
             if cursor.intersects(frame_rect.shrink(1.0)) {
                 // make row/column larger if necessary

crates/egui/src/placer.rs

@@ -133,8 +133,8 @@ impl Placer {
 
     /// Apply justify or alignment after calling `next_space`.
     pub(crate) fn justify_and_align(&self, rect: Rect, child_size: Vec2) -> Rect {
-        debug_assert!(!rect.any_nan());
-        debug_assert!(!child_size.any_nan());
+        debug_assert!(!rect.any_nan(), "rect: {rect:?}");
+        debug_assert!(!child_size.any_nan(), "child_size is NaN: {child_size:?}");
 
         if let Some(grid) = &self.grid {
             grid.justify_and_align(rect, child_size)
@@ -164,8 +164,11 @@ impl Placer {
         widget_rect: Rect,
         item_spacing: Vec2,
     ) {
-        debug_assert!(!frame_rect.any_nan());
-        debug_assert!(!widget_rect.any_nan());
+        debug_assert!(!frame_rect.any_nan(), "frame_rect: {frame_rect:?}");
+        debug_assert!(
+            !widget_rect.any_nan(),
+            "widget_rect is NaN: {widget_rect:?}"
+        );
         self.region.sanity_check();
 
         if let Some(grid) = &mut self.grid {

crates/egui/src/response.rs

@@ -985,7 +985,10 @@ impl Response {
     ///
     /// You may not call [`Self::interact`] on the resulting `Response`.
     pub fn union(&self, other: Self) -> Self {
-        assert!(self.ctx == other.ctx);
+        assert!(
+            self.ctx == other.ctx,
+            "Responses must be from the same `Context`"
+        );
         debug_assert!(
             self.layer_id == other.layer_id,
             "It makes no sense to combine Responses from two different layers"

crates/egui/src/text_selection/text_cursor_state.rs

@@ -271,7 +271,12 @@ pub fn byte_index_from_char_index(s: &str, char_index: usize) -> usize {
 }
 
 pub fn slice_char_range(s: &str, char_range: std::ops::Range<usize>) -> &str {
-    assert!(char_range.start <= char_range.end);
+    assert!(
+        char_range.start <= char_range.end,
+        "Invalid range, start must be less than end, but start = {}, end = {}",
+        char_range.start,
+        char_range.end
+    );
     let start_byte = byte_index_from_char_index(s, char_range.start);
     let end_byte = byte_index_from_char_index(s, char_range.end);
     &s[start_byte..end_byte]

crates/egui/src/text_selection/visuals.rs

@@ -59,7 +59,11 @@ pub fn paint_text_selection(
         // Start by appending the selection rectangle to end of the mesh, as two triangles (= 6 indices):
         let num_indices_before = mesh.indices.len();
         mesh.add_colored_rect(rect, color);
-        assert_eq!(num_indices_before + 6, mesh.indices.len());
+        assert_eq!(
+            num_indices_before + 6,
+            mesh.indices.len(),
+            "We expect exactly 6 new indices"
+        );
 
         // Copy out the new triangles:
         let selection_triangles = [