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.
@@ -557,6 +558,14 @@ 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 fmt::Display for AsciiChar {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -600,3 +609,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

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