Refine some staticstring! macro related stuff a bit more

Author: slightlyoutofphase

demo/string_demo.rs

@@ -93,10 +93,16 @@ fn main() {
   println!("Value: {}", STATIC_UNICODE);
   println!("Debug info: {:?}", STATIC_UNICODE);
   println!("Length: {}", STATIC_UNICODE.len());
-  println!("Remaining capacity: {}", STATIC_UNICODE.remaining_capacity());
+  println!(
+    "Remaining capacity: {}",
+    STATIC_UNICODE.remaining_capacity()
+  );
   let runtime_unicode = staticstring!("🙉🙉💣💣🙉🙉💣💣🙉🙉💣💣", 255);
   println!("Value: {}", runtime_unicode);
   println!("Debug info: {:?}", runtime_unicode);
   println!("Length: {}", runtime_unicode.len());
-  println!("Remaining capacity: {}", runtime_unicode.remaining_capacity());
+  println!(
+    "Remaining capacity: {}",
+    runtime_unicode.remaining_capacity()
+  );
 }

src/lib.rs

@@ -1750,11 +1750,6 @@ impl<const N: usize> StaticVec<u8, N> {
   #[doc(hidden)]
   #[inline]
   pub(crate) const fn bytes_to_data(values: &[u8]) -> MaybeUninit<[u8; N]> {
-    // This works at compile time too, of course.
-    assert!(
-      values.len() <= N,
-      "Attempted to create a `StaticString` with insufficient capacity from an `&str` literal!"
-    );
     // What follows is an idea partially arrived at from reading the source of the `const-concat`
     // crate. Note that it amounts to effectively a `const fn` compatible implementation of what
     // `MaybeUninit::assume_uninit()` does, and is *only* used here due to there being no other way
@@ -1779,7 +1774,7 @@ impl<const N: usize> StaticVec<u8, N> {
     // you, `const_loop`!
     let mut i = 0;
     while i < values.len() {
-      // We've statically asserted that `values.len() <= N` at the top of this overall function,
+      // We've statically asserted that `values.len() <= N` before entering this overall function,
       // so there's no concern that we might go out of bounds here (although that would still just
       // result in compilation not actually succeeding at all due to the `const` index error).
       res[i] = MaybeUninit::new(values[i]);
@@ -1796,6 +1791,15 @@ impl<const N: usize> StaticVec<u8, N> {
   #[doc(hidden)]
   #[inline(always)]
   pub const fn __new_from_const_str(values: &str) -> Self {
+    // This works at compile time too, of course, thanks to the `const_panic` feature.
+    assert!(
+      values.len() <= N,
+      // At the moment, I don't think this message is actually printed in any context when the
+      // assertion gets triggered (currently it's just "could not evaluate static initializer") but
+      // I feel like it doesn't hurt to have here just in case the compiler-error behavior changes
+      // such that custom messages are actually shown.
+      "Attempted to create a `StaticString` with insufficient capacity from an `&str` literal!"
+    );
     Self::new_from_str_data(Self::bytes_to_data(values.as_bytes()), values.len())
   }
 }

src/macros.rs

@@ -63,6 +63,8 @@ macro_rules! staticvec {
 /// // keeping in mind that length is measured in bytes and not characters of course:
 /// const S4: StaticString<36> = staticstring!("BC🤔BC🤔BC🤔", 36);
 /// assert_eq!(S4, "BC🤔BC🤔BC🤔");
+/// assert_eq!(S4.len(), 18);
+/// assert_eq!(S4.capacity(), 36);
 /// ```
 ///
 /// Note that attempting to explicitly provide a capacity that is less than the number of bytes
@@ -90,8 +92,8 @@ macro_rules! staticstring {
   };};
   ($val:expr, $n:expr) => {{
     // In this scenario, an actual assertion inside of `StaticVec::bytes_to_data`
-    // (available at compile time thanks to the `const_panic` feature)
-    // handles ensuring that `$val.len() <= N` for us.
+    // (available at compile time thanks to the `const_panic` feature) handles 
+    // ensuring that `$val.len() <= N` for us.
     unsafe {
       $crate::StaticString::<$n>::__new_from_staticvec(
         $crate::StaticVec::<u8, $n>::__new_from_const_str($val)