feat: simplify hex-display

Author: demosdemon

.github/workflows/ci.yml

@@ -43,8 +43,6 @@ jobs:
           - macos-latest
           - windows-latest
         rust:
-          - "1.86"
-          - "1.87"
           - "1.88"
           - "1.89"
           - "1.90"

Cargo.toml

@@ -15,7 +15,7 @@ readme = "README.md"
 keywords = ["git", "git-remote", "codecommit"]
 categories = ["command-line-utilities", "development-tools"]
 publish = true
-rust-version = "1.86"
+rust-version = "1.88"
 
 [workspace.lints.rust]
 let_underscore_drop = "warn"

README.md

@@ -39,7 +39,7 @@ Actively used on Windows, macOS, and low-resource Linux environments.
 
 ### MSRV
 
-The minimum supported Rust version is `1.86`.
+The minimum supported Rust version is `1.88`.
 
 ## Install
 

clippy.toml

@@ -1,4 +1,4 @@
 # See https://doc.rust-lang.org/clippy/lint_configuration.html
 # for full configuration options.
 
-msrv = "1.86"
+msrv = "1.88"

crates/git-remote-codecommit/src/hex.rs

@@ -1,21 +1,56 @@
-pub struct HexDisplay<T>(T);
+pub struct HexDisplay([u8; 32]);
 
-impl<T: AsRef<[u8]>> core::fmt::Display for HexDisplay<T> {
+impl core::fmt::Debug for HexDisplay {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        for b in self.0.as_ref() {
-            write!(f, "{b:02x}")?;
-        }
-        Ok(())
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
+impl core::fmt::Display for HexDisplay {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        // this implementation avoids any heap allocations and is optimized by
+        // the compiler to use vectorized instructions where available.
+        //
+        // with O3, the loop is unrolled and vectorized to use SIMD instructions
+        //
+        // https://rust.godbolt.org/z/seM19zEfv
+
+        let mut buf = [0u8; 64];
+        // SAFETY: 64 is evenly divisible by 2
+        unsafe { buf.as_chunks_unchecked_mut::<2>() }
+            .iter_mut()
+            .zip(self.0.as_ref())
+            .for_each(|(slot, &byte)| {
+                *slot = byte_to_hex(byte);
+            });
+
+        // SAFETY: buf only contains valid ASCII hex characters
+        let buf = unsafe { core::str::from_utf8_unchecked(&buf) };
+
+        f.pad(buf)
     }
 }
 
-pub trait HexDisplayExt: AsRef<[u8]> {
-    fn hex_display(self) -> HexDisplay<Self>
-    where
-        Self: Sized,
-    {
-        HexDisplay(self)
+const fn byte_to_hex(byte: u8) -> [u8; 2] {
+    const unsafe fn nibble_to_hex(nibble: u8) -> u8 {
+        match nibble {
+            0..=9 => b'0' + nibble,
+            10..=15 => b'a' + (nibble - 10),
+            // SAFETY: invariant held by caller that nibble is in 0..=15
+            _ => unsafe { core::hint::unreachable_unchecked() },
+        }
     }
+
+    // SAFETY: shifting and masking ensures nibble is in 0..=15 for both calls
+    unsafe { [nibble_to_hex(byte >> 4), nibble_to_hex(byte & 0x0F)] }
 }
 
-impl<T: AsRef<[u8]>> HexDisplayExt for T {}
+pub trait HexDisplayExt {
+    fn hex_display(self) -> HexDisplay;
+}
+
+impl<T: Into<[u8; 32]>> HexDisplayExt for T {
+    fn hex_display(self) -> HexDisplay {
+        HexDisplay(self.into())
+    }
+}