core: implement Add for ascii::Char; drop ascii::Char::digit

Implement Add for ascii::Char which panics in debug builds if sum isn’t
an ASCII character and wraps the result in release builds.  This covers
use cases of digit and digit_unchecked methods so remove them as well.
Those methods can now be replaced by simple addition:

    use core::ascii;

    assert_eq!(ascii::Char::Digit8, ascii::Char::Digit0 + 8);

Issue: #110998

Author: mina86

library/core/src/ascii/ascii_char.rs

@@ -5,6 +5,7 @@
 
 use crate::fmt::{self, Write};
 use crate::mem::transmute;
+use crate::ops::{Add, AddAssign};
 
 /// One of the 128 Unicode characters from U+0000 through U+007F,
 /// often known as the [ASCII] subset.
@@ -471,50 +472,6 @@ impl AsciiChar {
         unsafe { transmute(b) }
     }
 
-    /// When passed the *number* `0`, `1`, …, `9`, returns the *character*
-    /// `'0'`, `'1'`, …, `'9'` respectively.
-    ///
-    /// If `d >= 10`, returns `None`.
-    #[unstable(feature = "ascii_char", issue = "110998")]
-    #[inline]
-    pub const fn digit(d: u8) -> Option<Self> {
-        if d < 10 {
-            // SAFETY: Just checked it's in-range.
-            Some(unsafe { Self::digit_unchecked(d) })
-        } else {
-            None
-        }
-    }
-
-    /// When passed the *number* `0`, `1`, …, `9`, returns the *character*
-    /// `'0'`, `'1'`, …, `'9'` respectively, without checking that it's in-range.
-    ///
-    /// # Safety
-    ///
-    /// This is immediate UB if called with `d > 64`.
-    ///
-    /// If `d >= 10` and `d <= 64`, this is allowed to return any value or panic.
-    /// Notably, it should not be expected to return hex digits, or any other
-    /// reasonable extension of the decimal digits.
-    ///
-    /// (This lose safety condition is intended to simplify soundness proofs
-    /// when writing code using this method, since the implementation doesn't
-    /// need something really specific, not to make those other arguments do
-    /// something useful. It might be tightened before stabilization.)
-    #[unstable(feature = "ascii_char", issue = "110998")]
-    #[inline]
-    pub const unsafe fn digit_unchecked(d: u8) -> Self {
-        debug_assert!(d < 10);
-
-        // SAFETY: `'0'` through `'9'` are U+00030 through U+0039,
-        // so because `d` must be 64 or less the addition can return at most
-        // 112 (0x70), which doesn't overflow and is within the ASCII range.
-        unsafe {
-            let byte = b'0'.unchecked_add(d);
-            Self::from_u8_unchecked(byte)
-        }
-    }
-
     /// Gets this ASCII character as a byte.
     #[unstable(feature = "ascii_char", issue = "110998")]
     #[inline]
@@ -557,6 +514,22 @@ impl [AsciiChar] {
     }
 }
 
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl From<AsciiChar> for u8 {
+    #[inline]
+    fn from(chr: AsciiChar) -> Self {
+        chr as u8
+    }
+}
+
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl From<AsciiChar> for char {
+    #[inline]
+    fn from(chr: AsciiChar) -> Self {
+        chr as u8 as char
+    }
+}
+
 #[unstable(feature = "ascii_char", issue = "110998")]
 impl fmt::Display for AsciiChar {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -600,3 +573,59 @@ impl fmt::Debug for AsciiChar {
         f.write_char('\'')
     }
 }
+
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl Add<u8> for AsciiChar {
+    type Output = 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.
+    ///
+    /// ```
+    /// #![feature(ascii_char, ascii_char_variants)]
+    /// use core::ascii::Char;
+    ///
+    /// assert_eq!(Char::Digit8, Char::Digit0 + 8);
+    /// ```
+    #[inline]
+    fn add(self, rhs: u8) -> Self::Output {
+        add_impl(self, rhs)
+    }
+}
+
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl Add<AsciiChar> for u8 {
+    type Output = AsciiChar;
+
+    #[inline]
+    fn add(self, rhs: AsciiChar) -> Self::Output {
+        add_impl(rhs, self)
+    }
+}
+
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl AddAssign<u8> for AsciiChar {
+    #[inline]
+    fn add_assign(&mut self, rhs: u8) {
+        *self = add_impl(*self, rhs)
+    }
+}
+
+forward_ref_binop! { impl Add, add for AsciiChar, u8 }
+forward_ref_binop! { impl Add, add for u8, AsciiChar }
+forward_ref_op_assign! { impl AddAssign, add_assign for AsciiChar, u8 }
+
+#[inline]
+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)
+    }
+}

library/core/tests/ascii_char.rs

@@ -0,0 +1,36 @@
+use core::ascii::Char;
+
+/// Tests addition of u8 values to ascii::Char;
+#[test]
+fn test_arithmetic_ok() {
+    assert_eq!(Char::Digit8, Char::Digit0 + 8);
+    assert_eq!(Char::Colon, Char::Digit0 + 10);
+    assert_eq!(Char::Digit8, 8 + Char::Digit0);
+    assert_eq!(Char::Colon, 10 + Char::Digit0);
+
+    let mut digit = Char::Digit0;
+    digit += 8;
+    assert_eq!(Char::Digit8, digit);
+}
+
+/// Tests addition resulting in invalid ASCII character results in a panic.
+///
+/// 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.
+#[test]
+#[should_panic]
+fn test_arithmetic_non_ascii() {
+    let _ = Char::Digit0 + 120;
+}
+
+/// Tests addition 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.
+#[test]
+#[should_panic]
+fn test_arithmetic_overflow() {
+    let _ = Char::Digit0 + 250;
+}

library/core/tests/lib.rs

@@ -125,6 +125,7 @@ mod alloc;
 mod any;
 mod array;
 mod ascii;
+mod ascii_char;
 mod asserting;
 mod async_iter;
 mod atomic;