refactor: depopulate unreachable!() messages

This _should_ shrink the binary size by reducing panic info.

Author: SKalt

src/ambiguous/domain_or_tagged_ref.rs

@@ -169,14 +169,13 @@ impl<'src> DomainOrRefSpan<'src> {
                     }
                 }
             }
-            _ => unreachable!(
-                "PortOrTagSpan::new() only terminates successfully at '/', '@', or EOF"
-            ),
+            _ => unreachable!(), //PortOrTagSpan::new() only terminates successfully at '/', '@', or EOF
         }
     }
 }
 
 #[cfg(test)]
+#[allow(clippy::indexing_slicing)]
 mod tests {
     use super::*;
     use crate::span::Lengthy;

src/ambiguous/host_or_path.rs

@@ -319,7 +319,7 @@ impl<'src> HostOrPathSpan<'src> {
         use Kind::*;
         let decider = self.2;
         match (self.kind(), target_kind) {
-            (_, Any) => unreachable!("calls to .narrow() must narrow, not broaden"),
+            (_, Any) => unreachable!(), // calls to .narrow() must narrow, not broaden
             (Path, HostOrPath) | (Host, HostOrPath) => Ok(self),
             (Any, _) | (HostOrPath, Path) | (HostOrPath, Host) => {
                 Ok(Self(self.0, target_kind, decider))
@@ -336,7 +336,8 @@ impl<'src> HostOrPathSpan<'src> {
 #[allow(
     clippy::cast_possible_truncation,
     clippy::arithmetic_side_effects,
-    clippy::unwrap_used
+    clippy::unwrap_used,
+    clippy::indexing_slicing
 )]
 mod tests {
     use super::*;

src/digest/algorithm.rs

@@ -136,13 +136,13 @@ impl<'src> Algorithm<'src> {
             Some(b'a'..=b'z') => {}
             Some(b'0'..=b'9') => return Compliance::Oci,
             Some(b'A'..=b'Z') => return Compliance::Distribution,
-            _ => unreachable!("by construction, an Algorithm may contain only [a-zA-Z0-9]"),
+            _ => unreachable!(), // by construction, an Algorithm may contain only [a-zA-Z0-9]
         };
         for c in bytes {
             match c {
                 b'a'..=b'z' | b'0'..=b'9' => {}
                 b'A'..=b'Z' => return Compliance::Distribution,
-                _ => unreachable!("by construction, an Algorithm may contain only [a-zA-Z0-9]"),
+                _ => unreachable!(), // by construction, an Algorithm may contain only [a-zA-Z0-9]
             }
         }
         Compliance::Universal

src/lib.rs

@@ -6,7 +6,6 @@
 #![warn(missing_docs)]
 #![warn(clippy::arithmetic_side_effects)]
 #![warn(clippy::index_refutable_slice)]
-// #![warn(clippy::indexing_slicing)]
 #![warn(clippy::doc_markdown)]
 #![warn(clippy::trivially_copy_pass_by_ref)] // TODO: consider inlining
 #![deny(clippy::cast_possible_truncation)]
@@ -29,7 +28,9 @@
 #![warn(clippy::try_err)]
 #![warn(clippy::todo)]
 #![warn(clippy::redundant_clone)]
-// #![warn(clippy::or_fun_call)] warns about ok_or(Error::at(...))
+// #![warn(clippy::unreachable)]      // used too often to enable
+// #![warn(clippy::indexing_slicing)] // used too often to enable
+// #![warn(clippy::or_fun_call)]      // warns about ok_or(Error::at(...))
 pub(crate) mod ambiguous;
 pub mod digest;
 pub mod err;
@@ -98,9 +99,8 @@ impl<'src> RefSpan<'src> {
             }),
             Some(b'@') | Some(b':') | None => match prefix {
                 DomainOrRefSpan::TaggedRef((name, _)) => Ok(name),
-                DomainOrRefSpan::Domain(_) => {
-                    unreachable!("if the left segment peeked an '@', it would parse as a TaggedRef")
-                }
+                DomainOrRefSpan::Domain(_) => unreachable!(),
+                // ^ if the left segment peeked an '@', it would parse as a TaggedRef
             },
             Some(_) => Error::at(index, err::Kind::PathInvalidChar).into(),
         }?; // TODO: check correctness

src/name/domain/host.rs

@@ -82,8 +82,8 @@ impl<'src> TryFrom<HostOrPathSpan<'src>> for HostSpan<'src> {
         let kind = match ambiguous.kind() {
             HostKind::Host | HostKind::HostOrPath => Ok(Kind::Name),
             HostKind::IpV6 => Ok(Kind::Ipv6),
-            HostKind::Path => ambiguous.narrow(HostKind::Host).map(|_| unreachable!()),
-            HostKind::Any => unreachable!("HostKind::Any should have been disambiguated"),
+            HostKind::Path => ambiguous.narrow(HostKind::Host).map(|_| unreachable!()), // just to unwrap the error
+            HostKind::Any => unreachable!(), // HostKind::Any should have been disambiguated
         }?;
         Ok(Self(Length::from_nonzero(ambiguous.short_len()), kind))
     }

src/name/domain/ipv6.rs

@@ -175,7 +175,7 @@ impl<'src> Ipv6Span<'src> {
                 }
             }
             7 => Ok(Self(ShortLength::from_nonzero(index))),
-            _ => unreachable!("group_count <= 7 enforced by checks on state.increment_group()"),
+            _ => unreachable!(), // group_count <= 7 enforced by checks on state.increment_group()
         }
     }
 }