From ec0151e7e46493ab1242a619ae3ea64438962d6a Mon Sep 17 00:00:00 2001 From: Geoffrey Oxberry Date: Fri, 22 May 2026 23:40:50 +0000 Subject: [PATCH] refactor(lading): convert structural-infallible .expect() to unreachable!() Replace .expect("...") at structural-infallible sites in the lading crate with .unwrap_or_else(|| unreachable!("...")). These are Cat-3 sites where the invariant is guaranteed by the surrounding code: NonZero* on literal nonzero constants, parse() on hard-coded valid strings, hyper Response ::builder().body() after a successful builder, and similar. No behavioural change, no fn-level annotations, no quarantine drops. Co-Authored-By: Claude Opus 4.7 --- lading/src/blackhole/http.rs | 2 +- lading/src/blackhole/tcp_rr.rs | 4 ++-- lading/src/codec.rs | 8 ++++++-- lading/src/config.rs | 6 ++++-- lading/src/generator/common.rs | 4 +++- lading/src/generator/file_tree.rs | 14 +++++++------- lading/src/generator/process_tree.rs | 15 ++++++++------- lading/src/generator/tcp_rr.rs | 4 ++-- lading/src/generator/udp.rs | 3 ++- lading/src/generator/unix_datagram.rs | 3 ++- 10 files changed, 37 insertions(+), 26 deletions(-) diff --git a/lading/src/blackhole/http.rs b/lading/src/blackhole/http.rs index bdeb688a3..24eacbcd8 100644 --- a/lading/src/blackhole/http.rs +++ b/lading/src/blackhole/http.rs @@ -95,7 +95,7 @@ fn default_headers() -> HeaderMap { header::CONTENT_TYPE, "application/json" .parse() - .expect("Not possible to parse into HeaderMap"), + .unwrap_or_else(|_| unreachable!("\"application/json\" is a valid HeaderValue")), ); map } diff --git a/lading/src/blackhole/tcp_rr.rs b/lading/src/blackhole/tcp_rr.rs index b81fc513c..cf32a2cd9 100644 --- a/lading/src/blackhole/tcp_rr.rs +++ b/lading/src/blackhole/tcp_rr.rs @@ -34,11 +34,11 @@ use crate::neper::metrics::{self, ThreadMetrics}; use crate::neper::thread; fn default_nonzero_u16() -> NonZeroU16 { - NonZeroU16::new(1).expect("1 is nonzero") + NonZeroU16::new(1).unwrap_or_else(|| unreachable!("1 is nonzero by construction")) } fn default_nonzero_usize() -> NonZeroUsize { - NonZeroUsize::new(1).expect("1 is nonzero") + NonZeroUsize::new(1).unwrap_or_else(|| unreachable!("1 is nonzero by construction")) } fn default_control_port() -> u16 { diff --git a/lading/src/codec.rs b/lading/src/codec.rs index dbef9694f..33ac36d9c 100644 --- a/lading/src/codec.rs +++ b/lading/src/codec.rs @@ -66,7 +66,11 @@ pub(crate) fn decode( .body(crate::full(format!( "Unsupported encoding type: {encoding}" ))) - .expect("failed to build response"), + .unwrap_or_else(|_| { + unreachable!( + "Response::builder().body() on an OK builder cannot fail" + ) + }), )); } } @@ -85,5 +89,5 @@ fn encoding_error_to_response( .body(crate::full(format!( "failed to decode input as {encoding}: {error}" ))) - .expect("failed to build response") + .unwrap_or_else(|_| unreachable!("Response::builder().body() on an OK builder cannot fail")) } diff --git a/lading/src/config.rs b/lading/src/config.rs index e1ff38d3b..a04686992 100644 --- a/lading/src/config.rs +++ b/lading/src/config.rs @@ -250,7 +250,7 @@ impl Default for Telemetry { Self::Prometheus { addr: "0.0.0.0:9000" .parse() - .expect("Not possible to parse to SocketAddr"), + .unwrap_or_else(|_| unreachable!("\"0.0.0.0:9000\" is a valid SocketAddr literal")), global_labels: FxHashMap::default(), } } @@ -484,7 +484,9 @@ fn load_directory_configs(dir: &Path) -> Result { } // Convert final merged PartialConfig to Config - Config::from_partial(merged_partial.expect("found_any ensures this is Some")) + Config::from_partial( + merged_partial.unwrap_or_else(|| unreachable!("the found_any guard above ensures Some")), + ) } #[cfg(test)] diff --git a/lading/src/generator/common.rs b/lading/src/generator/common.rs index c947aba46..cb7cc0ada 100644 --- a/lading/src/generator/common.rs +++ b/lading/src/generator/common.rs @@ -151,7 +151,9 @@ impl BlockThrottle { ) -> Result<(), lading_throttle::Error> { let tokens: NonZeroU32 = match self.mode { ThrottleMode::Bytes => block_cache.peek_next_size(handle), - ThrottleMode::Blocks => NonZeroU32::new(1).expect("non-zero"), + ThrottleMode::Blocks => { + NonZeroU32::new(1).unwrap_or_else(|| unreachable!("1 is nonzero by construction")) + } }; self.inner.wait_for(tokens).await } diff --git a/lading/src/generator/file_tree.rs b/lading/src/generator/file_tree.rs index 2fec9ba03..ca1da942a 100644 --- a/lading/src/generator/file_tree.rs +++ b/lading/src/generator/file_tree.rs @@ -84,31 +84,31 @@ pub enum Error { } fn default_max_depth() -> NonZeroUsize { - NonZeroUsize::new(10).expect("default max depth given was 0") + NonZeroUsize::new(10).unwrap_or_else(|| unreachable!("10 is nonzero by construction")) } fn default_max_sub_folders() -> NonZeroU32 { - NonZeroU32::new(5).expect("default max sub folders given was 0") + NonZeroU32::new(5).unwrap_or_else(|| unreachable!("5 is nonzero by construction")) } fn default_max_files() -> NonZeroU32 { - NonZeroU32::new(5).expect("default max files given was 0") + NonZeroU32::new(5).unwrap_or_else(|| unreachable!("5 is nonzero by construction")) } fn default_max_nodes() -> NonZeroUsize { - NonZeroUsize::new(100).expect("default max nodes given was 0") + NonZeroUsize::new(100).unwrap_or_else(|| unreachable!("100 is nonzero by construction")) } fn default_name_len() -> NonZeroUsize { - NonZeroUsize::new(8).expect("default name len given was 0") + NonZeroUsize::new(8).unwrap_or_else(|| unreachable!("8 is nonzero by construction")) } fn default_open_per_second() -> NonZeroU32 { - NonZeroU32::new(8).expect("default open per second given was 0") + NonZeroU32::new(8).unwrap_or_else(|| unreachable!("8 is nonzero by construction")) } fn default_rename_per_name() -> NonZeroU32 { - NonZeroU32::new(1).expect("default rename per second given was 0") + NonZeroU32::new(1).unwrap_or_else(|| unreachable!("1 is nonzero by construction")) } #[derive(Debug, Deserialize, Serialize, PartialEq, Clone)] diff --git a/lading/src/generator/process_tree.rs b/lading/src/generator/process_tree.rs index 89f177f8e..f475716c6 100644 --- a/lading/src/generator/process_tree.rs +++ b/lading/src/generator/process_tree.rs @@ -97,32 +97,33 @@ pub enum Error { } fn default_max_depth() -> NonZeroU32 { - NonZeroU32::new(10).expect("default max depth given was 0") + NonZeroU32::new(10).unwrap_or_else(|| unreachable!("10 is nonzero by construction")) } // default to 100ms fn default_process_sleep_ns() -> NonZeroU32 { - NonZeroU32::new(100_000_000).expect("default process sleep ns given was 0") + NonZeroU32::new(100_000_000) + .unwrap_or_else(|| unreachable!("100_000_000 is nonzero by construction")) } fn default_max_children() -> NonZeroU32 { - NonZeroU32::new(10).expect("default max children given was 0") + NonZeroU32::new(10).unwrap_or_else(|| unreachable!("10 is nonzero by construction")) } fn default_args_len() -> NonZeroUsize { - NonZeroUsize::new(10).expect("default args len given was 0") + NonZeroUsize::new(10).unwrap_or_else(|| unreachable!("10 is nonzero by construction")) } fn default_args_count() -> NonZeroU32 { - NonZeroU32::new(16).expect("default args count given was 0") + NonZeroU32::new(16).unwrap_or_else(|| unreachable!("16 is nonzero by construction")) } fn default_envs_len() -> NonZeroUsize { - NonZeroUsize::new(16).expect("default envs len given was 0") + NonZeroUsize::new(16).unwrap_or_else(|| unreachable!("16 is nonzero by construction")) } fn default_envs_count() -> NonZeroU32 { - NonZeroU32::new(10).expect("default envs count given was 0") + NonZeroU32::new(10).unwrap_or_else(|| unreachable!("10 is nonzero by construction")) } #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)] diff --git a/lading/src/generator/tcp_rr.rs b/lading/src/generator/tcp_rr.rs index 5a7a3394d..ca39e3ca1 100644 --- a/lading/src/generator/tcp_rr.rs +++ b/lading/src/generator/tcp_rr.rs @@ -32,11 +32,11 @@ use crate::neper::metrics::{self, ThreadMetrics}; use crate::neper::thread; fn default_nonzero_u16() -> NonZeroU16 { - NonZeroU16::new(1).expect("1 is nonzero") + NonZeroU16::new(1).unwrap_or_else(|| unreachable!("1 is nonzero by construction")) } fn default_nonzero_usize() -> NonZeroUsize { - NonZeroUsize::new(1).expect("1 is nonzero") + NonZeroUsize::new(1).unwrap_or_else(|| unreachable!("1 is nonzero by construction")) } const fn default_true() -> bool { diff --git a/lading/src/generator/udp.rs b/lading/src/generator/udp.rs index d37b35fd3..ecbcf2a66 100644 --- a/lading/src/generator/udp.rs +++ b/lading/src/generator/udp.rs @@ -46,7 +46,8 @@ fn default_bind_addr() -> SocketAddr { // https://stackoverflow.com/a/42610200 fn maximum_block_size() -> Byte { - Byte::from_u64_with_unit(65_507, Unit::B).expect("catastrophic programming bug") + Byte::from_u64_with_unit(65_507, Unit::B) + .unwrap_or_else(|| unreachable!("65_507 bytes is a representable Byte value")) } #[derive(Debug, Deserialize, Serialize, PartialEq, Clone)] diff --git a/lading/src/generator/unix_datagram.rs b/lading/src/generator/unix_datagram.rs index 2f621789c..7fd45426f 100644 --- a/lading/src/generator/unix_datagram.rs +++ b/lading/src/generator/unix_datagram.rs @@ -38,7 +38,8 @@ fn default_parallel_connections() -> u16 { // Mimic the belief of Datadog Agent, although correctly we should be reading // sysctl values on Linux. fn maximum_block_size() -> Byte { - Byte::from_u64_with_unit(8_192, Unit::B).expect("catastrophic programming bug") + Byte::from_u64_with_unit(8_192, Unit::B) + .unwrap_or_else(|| unreachable!("8_192 bytes is a representable Byte value")) } #[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]