fix wrapping

Author: mina86

library/core/src/ascii/ascii_char.rs

@@ -617,17 +617,26 @@ impl Add<u8> for AsciiChar {
     /// Calculates sum of the ASCII value and given offset.
     ///
     /// In debug builds, panics if result is greater than largest ASCII value.
-    ///
     /// In release builds wraps the value (i.e. masks out the most significant
     /// bit) so the output is a valid ASCII character.
     ///
+    /// # Examples
+    ///
     /// ```
     /// #![feature(ascii_char, ascii_char_variants)]
     /// use core::ascii::Char;
     ///
     /// assert_eq!(Char::Digit8, Char::Digit0 + 8);
     /// ```
+    ///
+    /// ```should_panic
+    /// #![feature(ascii_char, ascii_char_variants)]
+    /// use core::ascii::Char;
+    ///
+    /// let _ = Char::Digit0 + 100;
+    /// ```
     #[inline]
+    #[rustc_inherit_overflow_checks]
     fn add(self, rhs: u8) -> Self::Output {
         add_impl(self, rhs)
     }
@@ -638,6 +647,7 @@ impl Add<AsciiChar> for u8 {
     type Output = AsciiChar;
 
     #[inline]
+    #[rustc_inherit_overflow_checks]
     fn add(self, rhs: AsciiChar) -> Self::Output {
         add_impl(rhs, self)
     }
@@ -646,6 +656,7 @@ impl Add<AsciiChar> for u8 {
 #[unstable(feature = "ascii_char", issue = "110998")]
 impl AddAssign<u8> for AsciiChar {
     #[inline]
+    #[rustc_inherit_overflow_checks]
     fn add_assign(&mut self, rhs: u8) {
         *self = add_impl(*self, rhs)
     }
@@ -656,12 +667,11 @@ forward_ref_binop! { impl Add, add for u8, AsciiChar }
 forward_ref_op_assign! { impl AddAssign, add_assign for AsciiChar, u8 }
 
 #[inline]
+#[rustc_inherit_overflow_checks]
 fn add_impl(chr: AsciiChar, rhs: u8) -> AsciiChar {
-    let sum = u16::from(u8::from(chr)) + u16::from(rhs);
-    if !cfg!(debug_assertions) || sum < 128 {
-        // SAFETY: `& 127` limits the sum to a valid ASCII value.
-        unsafe { AsciiChar::from_u8_unchecked((sum as u8) & 127) }
-    } else {
-        panic!("{} + {} overflows ASCII value", u8::from(chr), rhs)
-    }
+    // Make sure we overflow if chr + rhs ≥ 128.  Since we inherit overflow
+    // checks, we’re wrap in release and panic in debug builds.
+    let sum = u8::from(chr) + 128 + rhs;
+    // SAFETY: `sum & 127` limits the sum to a valid ASCII value.
+    unsafe { AsciiChar::from_u8_unchecked(sum & 127) }
 }

library/core/tests/ascii_char.rs

@@ -13,24 +13,32 @@ fn test_arithmetic_ok() {
     assert_eq!(Char::Digit8, digit);
 }
 
-/// Tests addition resulting in invalid ASCII character results in a panic.
+/// Tests addition wraps values when built in release mode.
+#[test]
+#[cfg_attr(debug_assertions, ignore)]
+fn test_arithmetic_wrapping() {
+    assert_eq!(Char::Digit0, Char::Digit8 + 120);
+    assert_eq!(Char::Digit0, Char::Digit8 + 248);
+}
+
+/// Tests addition panics in debug build when it produces an invalid ASCII char.
 ///
-/// Note: In release builds the result is wrapped instead of panicking.  Since
-/// everything is built in debug mode when testing, this behaviour is not
-/// currently tested.
+/// Note: Rust tests (at least when run via `./x.py test library/core`) are
+/// built in release mode so this test is normally ignored.  However, we have
+/// a doctest which checks the behaviour.
 #[test]
-#[should_panic]
+#[cfg_attr(not(debug_assertions), ignore)]
 fn test_arithmetic_non_ascii() {
     let _ = Char::Digit0 + 120;
 }
 
-/// Tests addition overflowing u8.
+/// Tests addition panics in debug build when it overflowing u8.
 ///
-/// Note: In release builds the result is wrapped instead of panicking.  Since
-/// everything is built in debug mode when testing, this behaviour is not
-/// currently tested.
+/// Note: Rust tests (at least when run via `./x.py test library/core`) are
+/// built in release mode so this test is normally ignored.  However, we have
+/// a doctest which checks the behaviour.
 #[test]
-#[should_panic]
+#[cfg_attr(not(debug_assertions), ignore)]
 fn test_arithmetic_overflow() {
     let _ = Char::Digit0 + 250;
 }