commit 8db4fdd05c485fed978937e65eb2deaa0e94172a parent d76142c7c046b17048ebd29823692820aaba9ce7 Author: triesap <tyson@radroots.org> Date: Mon, 6 Jul 2026 02:04:57 +0000 workspace: satisfy clippy final gate Diffstat:
41 files changed, 225 insertions(+), 193 deletions(-)
diff --git a/crates/events_codec/src/knowledge/encode.rs b/crates/events_codec/src/knowledge/encode.rs @@ -187,9 +187,10 @@ pub fn wiki_redirect_build_tags( redirect: &RadrootsWikiRedirect, ) -> Result<Vec<Vec<String>>, EventEncodeError> { validate_wiki_redirect(redirect).map_err(encode_validation_error)?; - let mut tags = Vec::new(); - tags.push(vec![TAG_D.to_string(), redirect.d_tag.clone()]); - tags.push(address_tag(TAG_A, &redirect.target)); + let tags = vec![ + vec![TAG_D.to_string(), redirect.d_tag.clone()], + address_tag(TAG_A, &redirect.target), + ]; Ok(tags) } diff --git a/crates/events_codec/src/manifest.rs b/crates/events_codec/src/manifest.rs @@ -105,7 +105,7 @@ pub fn knowledge_contract_manifest() -> RadrootsKnowledgeContractManifest { .filter(|contract| { event_contract_family(contract) == Some(RadrootsContractFamily::Knowledge) }) - .map(|contract| manifest_entry(contract)) + .map(manifest_entry) .collect::<Vec<_>>(); contracts.sort_by(|left, right| left.contract_id.cmp(&right.contract_id)); diff --git a/crates/events_codec/tests/knowledge_fixtures.rs b/crates/events_codec/tests/knowledge_fixtures.rs @@ -142,11 +142,7 @@ fn golden_knowledge_fixtures_cover_every_contract() { .collect::<BTreeSet<_>>(); let registry_contracts = all_event_contracts() .iter() - .filter(|contract| { - RADROOTS_KNOWLEDGE_VALID_CONTRACT_IDS - .iter() - .any(|contract_id| *contract_id == contract.id) - }) + .filter(|contract| RADROOTS_KNOWLEDGE_VALID_CONTRACT_IDS.contains(&contract.id)) .map(|contract| contract.id) .collect::<BTreeSet<_>>(); diff --git a/crates/geocoder/src/geocoder.rs b/crates/geocoder/src/geocoder.rs @@ -675,7 +675,7 @@ mod tests { #[test] fn unit_harness_covers_open_path_pathbuf_instantiation() { let path = build_fixture_database(); - let geocoder = Geocoder::open_path(path.to_path_buf()).expect("open geocoder from pathbuf"); + let geocoder = Geocoder::open_path(&path).expect("open geocoder from pathbuf"); let results = geocoder .country("US") .expect("country query from pathbuf geocoder"); @@ -1098,6 +1098,7 @@ mod tests { .expect_err("country center row decode should fail") } + #[allow(clippy::too_many_arguments)] fn map_reverse_row_error( id_sql: &str, name_sql: &str, diff --git a/crates/log/src/lib.rs b/crates/log/src/lib.rs @@ -92,7 +92,7 @@ mod tests { let _ = tracing::subscriber::set_global_default(TestSubscriber); let span = tracing::span!(tracing::Level::INFO, "log_span", value = 1); let other = tracing::span!(tracing::Level::INFO, "log_span_other"); - span.record("value", &2); + span.record("value", 2); span.follows_from(other.id()); let _enter = span.enter(); tracing::event!(tracing::Level::INFO, "log_event"); diff --git a/crates/nostr/src/events/application_handler.rs b/crates/nostr/src/events/application_handler.rs @@ -160,8 +160,10 @@ mod tests { #[test] fn metadata_has_fields_true_when_about_is_set() { - let mut metadata = RadrootsNostrMetadata::default(); - metadata.about = Some("ready".to_string()); + let metadata = RadrootsNostrMetadata { + about: Some("ready".to_string()), + ..Default::default() + }; assert!(radroots_nostr_metadata_has_fields(&metadata)); } } diff --git a/crates/nostr/tests/coverage.rs b/crates/nostr/tests/coverage.rs @@ -222,7 +222,7 @@ fn parse_helpers_cover_success_and_failure() { let invalid = radroots_nostr_parse_pubkey("invalid"); assert!(invalid.is_err()); - let parsed = radroots_nostr_parse_pubkeys(&[pubkey_hex.clone()]); + let parsed = radroots_nostr_parse_pubkeys(std::slice::from_ref(&pubkey_hex)); assert!(parsed.is_ok()); let parse_err = radroots_nostr_parse_pubkeys(&[pubkey_hex, "invalid".to_string()]); diff --git a/crates/nostr_accounts/src/manager.rs b/crates/nostr_accounts/src/manager.rs @@ -883,14 +883,17 @@ mod tests { #[test] fn new_reports_save_error_when_dirty_state_requires_rewrite() { - let mut state = RadrootsNostrAccountStoreState::default(); - state.default_account_id = Some(RadrootsIdentity::generate().id()); + let state = RadrootsNostrAccountStoreState { + default_account_id: Some(RadrootsIdentity::generate().id()), + ..Default::default() + }; let store = Arc::new(SaveErrorStore::new(state)); let vault = Arc::new(RadrootsNostrSecretVaultMemory::new()); - let err = RadrootsNostrAccountsManager::new(store, vault) - .err() - .expect("dirty state save error"); + let err = match RadrootsNostrAccountsManager::new(store, vault) { + Ok(_) => panic!("dirty state save error"), + Err(err) => err, + }; assert_eq!(err.to_string(), "store error: store save failed"); } @@ -918,7 +921,7 @@ mod tests { #[test] fn new_local_file_backed_rejects_external_command_backend() { let temp = tempfile::tempdir().expect("tempdir"); - let err = RadrootsNostrAccountsManager::new_local_file_backed( + let err = match RadrootsNostrAccountsManager::new_local_file_backed( temp.path().join("accounts.json"), temp.path().join("secrets"), RadrootsSecretBackendSelection { @@ -931,9 +934,10 @@ mod tests { memory: false, }, "org.radroots.test.local-account", - ) - .err() - .expect("external command must be rejected"); + ) { + Ok(_) => panic!("external command must be rejected"), + Err(err) => err, + }; assert_eq!( err.to_string(), @@ -944,7 +948,7 @@ mod tests { #[test] fn new_local_file_backed_reports_backend_resolution_error() { let temp = tempfile::tempdir().expect("tempdir"); - let err = RadrootsNostrAccountsManager::new_local_file_backed( + let err = match RadrootsNostrAccountsManager::new_local_file_backed( temp.path().join("accounts.json"), temp.path().join("secrets"), RadrootsSecretBackendSelection { @@ -959,9 +963,10 @@ mod tests { memory: false, }, "org.radroots.test.local-account", - ) - .err() - .expect("backend resolution error"); + ) { + Ok(_) => panic!("backend resolution error"), + Err(err) => err, + }; assert_eq!( err.to_string(), @@ -972,7 +977,7 @@ mod tests { #[test] fn new_local_file_backed_reports_store_load_error() { let temp = tempfile::tempdir().expect("tempdir"); - let err = RadrootsNostrAccountsManager::new_local_file_backed( + let err = match RadrootsNostrAccountsManager::new_local_file_backed( temp.path(), temp.path().join("secrets"), RadrootsSecretBackendSelection { @@ -985,9 +990,10 @@ mod tests { memory: false, }, "org.radroots.test.local-account", - ) - .err() - .expect("store load error"); + ) { + Ok(_) => panic!("store load error"), + Err(err) => err, + }; assert!(err.to_string().starts_with("store error:")); } @@ -1019,15 +1025,16 @@ mod tests { #[cfg(not(feature = "os-keyring"))] fn local_file_backed_secret_vault_rejects_host_vault_without_feature() { let temp = tempfile::tempdir().expect("tempdir"); - let err = local_file_backed_secret_vault( + let err = match local_file_backed_secret_vault( RadrootsSecretBackend::HostVault( radroots_secret_vault::RadrootsHostVaultPolicy::desktop(), ), temp.path(), "org.radroots.test.local-account".into(), - ) - .err() - .expect("host vault requires feature"); + ) { + Ok(_) => panic!("host vault requires feature"), + Err(err) => err, + }; assert_eq!( err.to_string(), @@ -1318,13 +1325,16 @@ mod tests { fn new_rejects_unsupported_schema_version() { let store = Arc::new(RadrootsNostrMemoryAccountStore::new()); let vault = Arc::new(RadrootsNostrSecretVaultMemory::new()); - let mut state = RadrootsNostrAccountStoreState::default(); - state.version = crate::model::RADROOTS_NOSTR_ACCOUNTS_STORE_VERSION + 1; + let state = RadrootsNostrAccountStoreState { + version: crate::model::RADROOTS_NOSTR_ACCOUNTS_STORE_VERSION + 1, + ..Default::default() + }; store.save(&state).expect("save"); - let err = RadrootsNostrAccountsManager::new(store, vault) - .err() - .expect("unsupported schema version"); + let err = match RadrootsNostrAccountsManager::new(store, vault) { + Ok(_) => panic!("unsupported schema version"), + Err(err) => err, + }; assert!(err.to_string().contains("invalid account state")); } @@ -1332,8 +1342,10 @@ mod tests { fn new_clears_orphaned_default_account() { let store = Arc::new(RadrootsNostrMemoryAccountStore::new()); let vault = Arc::new(RadrootsNostrSecretVaultMemory::new()); - let mut state = RadrootsNostrAccountStoreState::default(); - state.default_account_id = Some(RadrootsIdentity::generate().id()); + let state = RadrootsNostrAccountStoreState { + default_account_id: Some(RadrootsIdentity::generate().id()), + ..Default::default() + }; store.save(&state).expect("save"); let manager = RadrootsNostrAccountsManager::new(store, vault).expect("manager"); @@ -1819,12 +1831,13 @@ mod tests { #[test] fn manager_propagates_store_and_vault_errors() { - let load_error = RadrootsNostrAccountsManager::new( + let load_error = match RadrootsNostrAccountsManager::new( Arc::new(LoadErrorStore), Arc::new(RadrootsNostrSecretVaultMemory::new()), - ) - .err() - .expect("load error manager"); + ) { + Ok(_) => panic!("load error manager"), + Err(err) => err, + }; assert!(load_error.to_string().starts_with("store error:")); let save_error_store = Arc::new(SaveErrorStore::new( diff --git a/crates/nostr_ndb/src/filter.rs b/crates/nostr_ndb/src/filter.rs @@ -184,8 +184,8 @@ mod tests { .with_limit(10) .with_search("coffee"); - assert_eq!(spec.event_ids_hex(), &[event_id.clone()]); - assert_eq!(spec.authors_hex(), &[author.clone()]); + assert_eq!(spec.event_ids_hex(), std::slice::from_ref(&event_id)); + assert_eq!(spec.authors_hex(), std::slice::from_ref(&author)); assert_eq!(spec.kinds(), &[1, 30023]); assert_eq!(spec.since_unix(), Some(200)); assert_eq!(spec.until_unix(), Some(300)); diff --git a/crates/nostr_ndb/src/ndb.rs b/crates/nostr_ndb/src/ndb.rs @@ -598,6 +598,7 @@ mod tests { } #[tokio::test] + #[allow(clippy::await_holding_lock)] async fn wait_for_note_keys_yields_results() { let _guard = test_hooks_guard(); reset_test_flags(); @@ -623,6 +624,7 @@ mod tests { } #[tokio::test] + #[allow(clippy::await_holding_lock)] async fn wait_for_note_keys_reports_ndb_error() { let _guard = test_hooks_guard(); reset_test_flags(); diff --git a/crates/nostr_ndb/src/subscription.rs b/crates/nostr_ndb/src/subscription.rs @@ -95,10 +95,10 @@ mod tests { let filter = RadrootsNostrNdbFilterSpec::new().with_kind(1); let from_new = RadrootsNostrNdbSubscriptionSpec::new(vec![filter.clone()]); - assert_eq!(from_new.filters(), &[filter.clone()]); + assert_eq!(from_new.filters(), std::slice::from_ref(&filter)); let from_single = RadrootsNostrNdbSubscriptionSpec::single(filter.clone()); - assert_eq!(from_single.filters(), &[filter.clone()]); + assert_eq!(from_single.filters(), std::slice::from_ref(&filter)); let text_notes = RadrootsNostrNdbSubscriptionSpec::text_notes(Some(10), Some(123)); assert_eq!(text_notes.filters().len(), 1); diff --git a/crates/nostr_signer/src/backend.rs b/crates/nostr_signer/src/backend.rs @@ -1062,9 +1062,11 @@ mod tests { .set_signer_identity(fixture_bob_identity()) .expect("set signer identity"); - let error = RadrootsNostrEmbeddedSignerBackend::new(manager, embedded_identity(0x91)) - .err() - .expect("mismatched identity"); + let error = match RadrootsNostrEmbeddedSignerBackend::new(manager, embedded_identity(0x91)) + { + Ok(_) => panic!("mismatched identity"), + Err(error) => error, + }; assert!( error .to_string() @@ -1766,9 +1768,8 @@ mod tests { "public_key_npub": "npub1invalid" })) .expect("invalid identity payload"); - let error = parse_identity_public_key(&invalid_identity) - .err() - .expect("invalid public identity"); + let error = + parse_identity_public_key(&invalid_identity).expect_err("invalid public identity"); assert!(error.to_string().contains("identity public key is invalid")); } diff --git a/crates/nostr_signer/src/error.rs b/crates/nostr_signer/src/error.rs @@ -99,9 +99,8 @@ mod tests { #[test] fn converts_serde_json_error() { - let source = serde_json::from_str::<serde_json::Value>("{not-json") - .err() - .expect("serde error"); + let source = + serde_json::from_str::<serde_json::Value>("{not-json").expect_err("serde error"); let converted: RadrootsNostrSignerError = source.into(); assert!(converted.to_string().starts_with("store error:")); } diff --git a/crates/nostr_signer/src/manager.rs b/crates/nostr_signer/src/manager.rs @@ -1432,16 +1432,24 @@ mod tests { .expect("load error store save"); let load_result = RadrootsNostrSignerManager::new(load_error_store); assert!(load_result.is_err()); - let err = load_result.err().expect("load error"); + let err = match load_result { + Ok(_) => panic!("load error"), + Err(err) => err, + }; assert!(err.to_string().contains("store load failed")); let store = Arc::new(RadrootsNostrMemorySignerStore::new()); - let mut state = RadrootsNostrSignerStoreState::default(); - state.version = 2; + let state = RadrootsNostrSignerStoreState { + version: 2, + ..Default::default() + }; store.save(&state).expect("save"); let version_result = RadrootsNostrSignerManager::new(store); assert!(version_result.is_err()); - let err = version_result.err().expect("invalid version"); + let err = match version_result { + Ok(_) => panic!("invalid version"), + Err(err) => err, + }; assert!( err.to_string() .contains("unsupported signer schema version") @@ -3328,8 +3336,10 @@ mod tests { #[test] fn register_connection_rejects_invalid_persisted_signer_identity() { let store = Arc::new(RadrootsNostrMemorySignerStore::new()); - let mut state = RadrootsNostrSignerStoreState::default(); - state.signer_identity = Some(invalid_public_identity(0x54)); + let state = RadrootsNostrSignerStoreState { + signer_identity: Some(invalid_public_identity(0x54)), + ..Default::default() + }; store.save(&state).expect("seed state"); let manager = RadrootsNostrSignerManager::new(store).expect("manager"); @@ -3411,8 +3421,10 @@ mod tests { fn evaluate_connect_request_reports_poisoned_state_lock() { let store = Arc::new(RadrootsNostrMemorySignerStore::new()); let signer_identity = public_identity(0x57); - let mut state = RadrootsNostrSignerStoreState::default(); - state.signer_identity = Some(signer_identity.clone()); + let state = RadrootsNostrSignerStoreState { + signer_identity: Some(signer_identity.clone()), + ..Default::default() + }; store.save(&state).expect("save state"); let manager = RadrootsNostrSignerManager::new(store).expect("manager"); @@ -3780,10 +3792,12 @@ mod tests { ); let store = Arc::new(RadrootsNostrMemorySignerStore::new()); - let mut invalid_state = RadrootsNostrSignerStoreState::default(); let mut invalid_identity = public_identity(0x69); invalid_identity.public_key_hex = "invalid".into(); - invalid_state.signer_identity = Some(invalid_identity); + let invalid_state = RadrootsNostrSignerStoreState { + signer_identity: Some(invalid_identity), + ..Default::default() + }; store .save(&invalid_state) .expect("save invalid signer state"); @@ -3940,8 +3954,10 @@ mod tests { fn evaluate_request_reports_invalid_corrupted_auth_state() { let store = Arc::new(RadrootsNostrMemorySignerStore::new()); let signer_identity = public_identity(0x78); - let mut state = RadrootsNostrSignerStoreState::default(); - state.signer_identity = Some(signer_identity.clone()); + let mut state = RadrootsNostrSignerStoreState { + signer_identity: Some(signer_identity.clone()), + ..Default::default() + }; let mut record = RadrootsNostrSignerConnectionRecord::new( RadrootsNostrSignerConnectionId::new_v7(), signer_identity, diff --git a/crates/replica_db/src/backup.rs b/crates/replica_db/src/backup.rs @@ -363,10 +363,10 @@ mod tests { .lock() .expect("exec calls lock") .push(sql.to_string()); - if let Some(needle) = &self.fail_exec_contains { - if sql.contains(needle) { - return Err(SqlError::InvalidQuery(String::from("forced exec failure"))); - } + if let Some(needle) = &self.fail_exec_contains + && sql.contains(needle) + { + return Err(SqlError::InvalidQuery(String::from("forced exec failure"))); } Ok(ExecOutcome { changes: 1, @@ -375,10 +375,10 @@ mod tests { } fn query_raw(&self, sql: &str, _params_json: &str) -> Result<String, SqlError> { - if let Some(needle) = &self.fail_query_contains { - if sql.contains(needle) { - return Err(SqlError::InvalidQuery(String::from("forced query failure"))); - } + if let Some(needle) = &self.fail_query_contains + && sql.contains(needle) + { + return Err(SqlError::InvalidQuery(String::from("forced query failure"))); } for (needle, response) in &self.query_rules { if sql.contains(needle) { diff --git a/crates/replica_db/src/export.rs b/crates/replica_db/src/export.rs @@ -119,10 +119,10 @@ mod tests { } fn query_raw(&self, sql: &str, _params_json: &str) -> Result<String, SqlError> { - if let Some(needle) = &self.fail_query_contains { - if sql.contains(needle) { - return Err(SqlError::InvalidQuery(String::from("forced query failure"))); - } + if let Some(needle) = &self.fail_query_contains + && sql.contains(needle) + { + return Err(SqlError::InvalidQuery(String::from("forced query failure"))); } for (needle, response) in &self.query_rules { if sql.contains(needle) { diff --git a/crates/replica_db/tests/backup_export_paths.rs b/crates/replica_db/tests/backup_export_paths.rs @@ -70,10 +70,10 @@ impl SqlExecutor for PatternExecutor { if let Some(result) = self.exec_queue.lock().expect("exec queue lock").pop_front() { return result; } - if let Some(needle) = &self.fail_exec_contains { - if sql.contains(needle) { - return Err(SqlError::InvalidQuery(String::from("forced exec failure"))); - } + if let Some(needle) = &self.fail_exec_contains + && sql.contains(needle) + { + return Err(SqlError::InvalidQuery(String::from("forced exec failure"))); } Ok(ExecOutcome { changes: 1, @@ -90,10 +90,10 @@ impl SqlExecutor for PatternExecutor { { return result; } - if let Some(needle) = &self.fail_query_contains { - if sql.contains(needle) { - return Err(SqlError::InvalidQuery(String::from("forced query failure"))); - } + if let Some(needle) = &self.fail_query_contains + && sql.contains(needle) + { + return Err(SqlError::InvalidQuery(String::from("forced query failure"))); } for (needle, response) in &self.query_rules { if sql.contains(needle) { diff --git a/crates/replica_sync/src/ingest.rs b/crates/replica_sync/src/ingest.rs @@ -1788,6 +1788,7 @@ mod tests { } } + #[allow(clippy::too_many_arguments)] fn plot_event( id: u64, author: &str, @@ -1972,8 +1973,7 @@ mod tests { assert!(err.to_string().contains("whole number")); let err = decimal_to_i64(&listing_decimal("9223372036854775808"), "listing inventory") - .err() - .expect("i64 overflow should fail"); + .expect_err("i64 overflow should fail"); assert!(err.to_string().contains("exceeds i64 range")); } @@ -2786,7 +2786,7 @@ mod tests { .expect("plot") .result; - let _ = upsert_plot_location(&exec, &plot_row.id, None, &FixedFactory).expect("plot none"); + upsert_plot_location(&exec, &plot_row.id, None, &FixedFactory).expect("plot none"); } #[test] diff --git a/crates/replica_sync/src/tests.rs b/crates/replica_sync/src/tests.rs @@ -239,7 +239,7 @@ fn sync_all_emits_expected_order() { fn unwrap_sql_panics_on_error() { let result = panic::catch_unwind(|| { let err = IError::from(SqlError::InvalidArgument("bad".to_string())); - let _ = unwrap_sql::<()>(Err(err), "unwrap"); + unwrap_sql::<()>(Err(err), "unwrap"); }); assert!(result.is_err()); } diff --git a/crates/replica_sync/tests/ingest_roundtrip.rs b/crates/replica_sync/tests/ingest_roundtrip.rs @@ -178,7 +178,7 @@ impl SqlExecutor for QueryFailExecutor<'_> { fn unwrap_sql_panics_on_error() { let result = panic::catch_unwind(|| { let err = IError::from(SqlError::InvalidArgument("bad".to_string())); - let _ = unwrap_sql::<()>(Err(err), "unwrap"); + unwrap_sql::<()>(Err(err), "unwrap"); }); assert!(result.is_err()); } @@ -1043,6 +1043,7 @@ fn farm_event( ) } +#[allow(clippy::too_many_arguments)] fn plot_event( id: u64, author: &str, diff --git a/crates/runtime/src/cli.rs b/crates/runtime/src/cli.rs @@ -1,5 +1,3 @@ -#![cfg(feature = "cli")] - use clap::Parser; use config::{Map, Value}; use serde::de::DeserializeOwned; diff --git a/crates/runtime/src/json.rs b/crates/runtime/src/json.rs @@ -205,7 +205,7 @@ mod test_hooks { fn write_temp_file(tmp: &mut NamedTempFile, bytes: &[u8]) -> io::Result<()> { #[cfg(test)] if test_hooks::take_write() { - return Err(io::Error::new(io::ErrorKind::Other, "forced write failure")); + return Err(io::Error::other("forced write failure")); } tmp.write_all(bytes) } @@ -213,7 +213,7 @@ fn write_temp_file(tmp: &mut NamedTempFile, bytes: &[u8]) -> io::Result<()> { fn sync_temp_file(tmp: &mut NamedTempFile) -> io::Result<()> { #[cfg(test)] if test_hooks::take_sync() { - return Err(io::Error::new(io::ErrorKind::Other, "forced sync failure")); + return Err(io::Error::other("forced sync failure")); } tmp.as_file_mut().sync_all() } @@ -222,10 +222,7 @@ fn sync_temp_file(tmp: &mut NamedTempFile) -> io::Result<()> { fn set_temp_permissions(path: &Path, mode: u32) -> io::Result<()> { #[cfg(test)] if test_hooks::take_perms() { - return Err(io::Error::new( - io::ErrorKind::Other, - "forced permissions failure", - )); + return Err(io::Error::other("forced permissions failure")); } fs::set_permissions(path, fs::Permissions::from_mode(mode)) } @@ -341,8 +338,7 @@ mod tests { #[test] fn load_reports_file_open_error_for_directory() { let dir = tempdir().expect("tempdir"); - let err = JsonFile::<Payload>::load(dir.path().to_path_buf()) - .expect_err("directory path should fail"); + let err = JsonFile::<Payload>::load(dir.path()).expect_err("directory path should fail"); assert!(err.to_string().contains("Failed to parse JSON")); assert!( err.to_string() @@ -379,8 +375,8 @@ mod tests { #[test] fn serialize_toggle_load_reports_file_open_error_for_directory() { let dir = tempdir().expect("tempdir"); - let err = JsonFile::<SerializeToggle>::load(dir.path().to_path_buf()) - .expect_err("directory path should fail"); + let err = + JsonFile::<SerializeToggle>::load(dir.path()).expect_err("directory path should fail"); assert!(err.to_string().contains("Failed to parse JSON")); assert!( err.to_string() diff --git a/crates/runtime/src/tracing.rs b/crates/runtime/src/tracing.rs @@ -72,7 +72,7 @@ mod test_hooks { thread_local! { static IGNORE_ENV: Cell<bool> = const { Cell::new(false) }; - static CURRENT_RESOLVER: RefCell<Option<RadrootsPathResolver>> = RefCell::new(None); + static CURRENT_RESOLVER: RefCell<Option<RadrootsPathResolver>> = const { RefCell::new(None) }; } pub fn set_ignore_env(ignore: bool) { diff --git a/crates/runtime_manager/src/lifecycle.rs b/crates/runtime_manager/src/lifecycle.rs @@ -1412,7 +1412,7 @@ mod tests { let blocked_path = restricted.join("child"); let mut permissions = fs::metadata(&restricted).expect("metadata").permissions(); - permissions.set_mode(0); + permissions.set_mode(0o0); fs::set_permissions(&restricted, permissions).expect("restrict permissions"); let err = remove_path_if_exists(&blocked_path).expect_err("metadata lookup should fail"); diff --git a/crates/simplex_agent_proto/src/short_link.rs b/crates/simplex_agent_proto/src/short_link.rs @@ -33,6 +33,7 @@ const SIMPLEX_RATCHET_KEM_ACCEPTED: u8 = b'A'; const SIMPLEX_USER_LINK_DATA_LARGE_TAG: u8 = u8::MAX; type ShortLinkResult<T> = Result<T, RadrootsSimplexAgentProtoError>; +type OptionalKemParams = (Option<Vec<u8>>, Option<Vec<u8>>); #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RadrootsSimplexAgentShortLinkScheme { @@ -786,7 +787,7 @@ impl<'a> ShortLinkDataCursor<'a> { fn read_optional_kem_params( &mut self, - ) -> Result<(Option<Vec<u8>>, Option<Vec<u8>>), RadrootsSimplexAgentProtoError> { + ) -> Result<OptionalKemParams, RadrootsSimplexAgentProtoError> { match self.read_byte()? { SIMPLEX_MAYBE_NOTHING => Ok((None, None)), SIMPLEX_MAYBE_JUST => match self.read_byte()? { diff --git a/crates/simplex_agent_runtime/src/runtime.rs b/crates/simplex_agent_runtime/src/runtime.rs @@ -2103,7 +2103,7 @@ impl RadrootsSimplexAgentRuntime { agent_message_hash.clone().unwrap_or_default(), )?; } - let message_hash = agent_message_hash.unwrap_or_else(|| transport_hash); + let message_hash = agent_message_hash.unwrap_or(transport_hash); self.handle_inbound_decrypted_message(connection_id, decrypted, message_hash)?; if !requires_app_ack { self.ack_broker_message(connection_id, queue.clone(), message.message_id, 0)?; @@ -3100,9 +3100,9 @@ mod tests { entity_id: request.entity_id.clone(), command: request.command.clone(), }; - let block = RadrootsSimplexSmpTransportBlock::from_current_command_transmissions(&[ - transmission.clone(), - ]) + let block = RadrootsSimplexSmpTransportBlock::from_current_command_transmissions( + std::slice::from_ref(&transmission), + ) .map_err(|error| error.to_string())?; let encoded = block.encode().map_err(|error| error.to_string())?; let decoded = RadrootsSimplexSmpTransportBlock::decode(&encoded) @@ -3124,7 +3124,7 @@ mod tests { message: response_message, }; let response_block = RadrootsSimplexSmpTransportBlock::from_broker_transmissions( - &[response_transmission.clone()], + std::slice::from_ref(&response_transmission), request.transport_version, ) .map_err(|error| error.to_string())?; @@ -3149,7 +3149,7 @@ mod tests { return Ok(None); }; let response_block = RadrootsSimplexSmpTransportBlock::from_broker_transmissions( - &[response_transmission.clone()], + std::slice::from_ref(&response_transmission), RADROOTS_SIMPLEX_SMP_CURRENT_TRANSPORT_VERSION, ) .map_err(|error| error.to_string())?; diff --git a/crates/simplex_agent_store/src/store.rs b/crates/simplex_agent_store/src/store.rs @@ -4184,7 +4184,7 @@ mod tests { link_id, link_data } if persisted_queue == &queue - && link_id.as_slice() == &[1_u8; 24] + && link_id.as_slice() == [1_u8; 24] && link_data.fixed_data.as_slice() == b"fixed-link-data" && link_data.user_data.as_slice() == b"user-link-data" ))); diff --git a/crates/simplex_app_store/src/store.rs b/crates/simplex_app_store/src/store.rs @@ -2700,8 +2700,7 @@ mod tests { .expect("draft"); let error = store .mark_outbox_message_acknowledged(&draft.outbox_message.outbox_id) - .err() - .expect("transition error"); + .expect_err("transition error"); assert!(matches!( error, diff --git a/crates/simplex_chat_proto/tests/chat_proto.rs b/crates/simplex_chat_proto/tests/chat_proto.rs @@ -243,7 +243,8 @@ fn roundtrips_official_compressed_envelope_batches() { } })); - let encoded = encode_compressed_batch(&[message.clone()]).expect("encode compressed batch"); + let encoded = + encode_compressed_batch(std::slice::from_ref(&message)).expect("encode compressed batch"); assert_eq!(encoded.first(), Some(&b'X')); let decoded = decode_messages(&encoded).expect("decode compressed envelope"); diff --git a/crates/simplex_interop_tests/src/lib.rs b/crates/simplex_interop_tests/src/lib.rs @@ -156,9 +156,9 @@ mod tests { entity_id: request.entity_id.clone(), command: request.command.clone(), }; - let block = RadrootsSimplexSmpTransportBlock::from_current_command_transmissions(&[ - transmission.clone(), - ]) + let block = RadrootsSimplexSmpTransportBlock::from_current_command_transmissions( + std::slice::from_ref(&transmission), + ) .map_err(|error| error.to_string())?; let encoded = block.encode().map_err(|error| error.to_string())?; let decoded = RadrootsSimplexSmpTransportBlock::decode(&encoded) @@ -179,7 +179,7 @@ mod tests { message: response_message, }; let response_block = RadrootsSimplexSmpTransportBlock::from_broker_transmissions( - &[response_transmission.clone()], + std::slice::from_ref(&response_transmission), request.transport_version, ) .map_err(|error| error.to_string())?; @@ -220,9 +220,9 @@ mod tests { entity_id: b"rr-synth-queue".to_vec(), command: send_command.clone(), }; - let block = RadrootsSimplexSmpTransportBlock::from_current_command_transmissions(&[ - transmission.clone(), - ]) + let block = RadrootsSimplexSmpTransportBlock::from_current_command_transmissions( + std::slice::from_ref(&transmission), + ) .unwrap(); let decoded = RadrootsSimplexSmpTransportBlock::decode(&block.encode().unwrap()) .unwrap() diff --git a/crates/simplex_interop_tests/src/policy.rs b/crates/simplex_interop_tests/src/policy.rs @@ -96,14 +96,11 @@ impl RadrootsSimplexInteropLocalUpstream { else { return Ok(None); }; - let server_identity = match required_or_optional( + let server_identity = required_or_optional( server_identity, required, RADROOTS_SIMPLEX_INTEROP_SMP_IDENTITY_ENV, - )? { - Some(value) => Some(value), - None => None, - }; + )?; Ok(Some(Self { host, port: port.parse::<u16>().map_err(|_| { diff --git a/crates/simplex_smp_crypto/src/official_ratchet.rs b/crates/simplex_smp_crypto/src/official_ratchet.rs @@ -39,6 +39,8 @@ const RADROOTS_SIMPLEX_OFFICIAL_X448_DER_PUBLIC_KEY_PREFIX: [u8; 12] = [ 0x30, 0x42, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6f, 0x03, 0x39, 0x00, ]; type RadrootsSimplexOfficialAes256Gcm = AesGcm<Aes256, U16>; +type RadrootsSimplexOfficialHkdf3Output = (Vec<u8>, Vec<u8>, Vec<u8>); +type RadrootsSimplexOfficialPqHeaderParts = (Option<Vec<u8>>, Option<Vec<u8>>); #[derive(Debug, Clone, PartialEq, Eq)] pub struct RadrootsSimplexOfficialX448Keypair { @@ -134,8 +136,8 @@ pub fn official_ratchet_header_len( version: u16, pq_enabled: bool, ) -> Result<usize, RadrootsSimplexSmpCryptoError> { - if version < RADROOTS_SIMPLEX_OFFICIAL_E2E_KDF_VERSION - || version > RADROOTS_SIMPLEX_OFFICIAL_E2E_CURRENT_VERSION + if !(RADROOTS_SIMPLEX_OFFICIAL_E2E_KDF_VERSION..=RADROOTS_SIMPLEX_OFFICIAL_E2E_CURRENT_VERSION) + .contains(&version) { return Err(RadrootsSimplexSmpCryptoError::InvalidOfficialRatchetVersion(version)); } @@ -841,7 +843,7 @@ fn official_hkdf3( salt: &[u8], ikm: &[u8], info: &[u8], -) -> Result<(Vec<u8>, Vec<u8>, Vec<u8>), RadrootsSimplexSmpCryptoError> { +) -> Result<RadrootsSimplexOfficialHkdf3Output, RadrootsSimplexSmpCryptoError> { let hkdf = Hkdf::<Sha512>::new(Some(salt), ikm); let mut output = [0_u8; RADROOTS_SIMPLEX_OFFICIAL_HKDF3_OUTPUT_LENGTH]; hkdf.expand(info, &mut output).map_err(|_| { @@ -859,8 +861,8 @@ fn official_hkdf3( } fn validate_official_version(version: u16) -> Result<(), RadrootsSimplexSmpCryptoError> { - if version < RADROOTS_SIMPLEX_OFFICIAL_E2E_KDF_VERSION - || version > RADROOTS_SIMPLEX_OFFICIAL_E2E_CURRENT_VERSION + if !(RADROOTS_SIMPLEX_OFFICIAL_E2E_KDF_VERSION..=RADROOTS_SIMPLEX_OFFICIAL_E2E_CURRENT_VERSION) + .contains(&version) { return Err(RadrootsSimplexSmpCryptoError::InvalidOfficialRatchetVersion(version)); } @@ -905,12 +907,12 @@ fn validate_official_x3dh_params( )); } } - if let Some(pq_ciphertext) = params.pq_ciphertext.as_deref() { - if pq_ciphertext.len() != RADROOTS_SIMPLEX_OFFICIAL_SNTRUP761_CIPHERTEXT_LENGTH { - return Err(RadrootsSimplexSmpCryptoError::InvalidPqCiphertextLength( - pq_ciphertext.len(), - )); - } + if let Some(pq_ciphertext) = params.pq_ciphertext.as_deref() + && pq_ciphertext.len() != RADROOTS_SIMPLEX_OFFICIAL_SNTRUP761_CIPHERTEXT_LENGTH + { + return Err(RadrootsSimplexSmpCryptoError::InvalidPqCiphertextLength( + pq_ciphertext.len(), + )); } Ok(()) } @@ -1029,7 +1031,7 @@ fn push_official_msg_header_pq( fn read_official_msg_header_pq( cursor: &mut OfficialCursor<'_>, -) -> Result<(Option<Vec<u8>>, Option<Vec<u8>>), RadrootsSimplexSmpCryptoError> { +) -> Result<RadrootsSimplexOfficialPqHeaderParts, RadrootsSimplexSmpCryptoError> { match cursor.read_byte()? { b'0' => Ok((None, None)), b'1' => match cursor.read_byte()? { diff --git a/crates/simplex_smp_crypto/src/ratchet.rs b/crates/simplex_smp_crypto/src/ratchet.rs @@ -585,12 +585,11 @@ impl RadrootsSimplexSmpRatchetState { ratchet_ad: &[u8], ) -> Result<(OfficialRatchetStep, RadrootsSimplexSmpRatchetHeader), RadrootsSimplexSmpCryptoError> { - if let Some(receiving_header_key) = self.official_receiving_header_key.as_ref() { - if let Ok(ratchet_header) = + if let Some(receiving_header_key) = self.official_receiving_header_key.as_ref() + && let Ok(ratchet_header) = decrypt_official_header_with_key(header, receiving_header_key, ratchet_ad) - { - return Ok((OfficialRatchetStep::Same, ratchet_header)); - } + { + return Ok((OfficialRatchetStep::Same, ratchet_header)); } let next_receiving_header_key = self.official_next_receiving_header_key.as_ref().ok_or( RadrootsSimplexSmpCryptoError::MissingRatchetKey("official_next_receiving_header_key"), diff --git a/crates/simplex_smp_transport/src/client.rs b/crates/simplex_smp_transport/src/client.rs @@ -1,5 +1,3 @@ -#![cfg(feature = "std")] - use crate::error::RadrootsSimplexSmpTransportError; use crate::executor::{ RadrootsSimplexSmpCommandTransport, RadrootsSimplexSmpSubscriptionReceiveRequest, @@ -425,7 +423,7 @@ fn decode_live_transport_block( ), )); } - return Err(error.into()); + return Err(error); } } } @@ -1013,7 +1011,7 @@ mod tests { command: RadrootsSimplexSmpCommand::Ping, }; let command_block = RadrootsSimplexSmpTransportBlock::from_command_transmissions( - &[command_transmission.clone()], + std::slice::from_ref(&command_transmission), RADROOTS_SIMPLEX_SMP_CURRENT_TRANSPORT_VERSION, ) .unwrap(); @@ -1037,7 +1035,7 @@ mod tests { message: RadrootsSimplexSmpBrokerMessage::Ok, }; let broker_block = RadrootsSimplexSmpTransportBlock::from_broker_transmissions( - &[broker_transmission.clone()], + std::slice::from_ref(&broker_transmission), RADROOTS_SIMPLEX_SMP_CURRENT_TRANSPORT_VERSION, ) .unwrap(); diff --git a/crates/sp1_guest_trade/src/lib.rs b/crates/sp1_guest_trade/src/lib.rs @@ -820,6 +820,15 @@ mod tests { reduce_order_acceptance_canonical_public_values, reduce_order_acceptance_public_values, }; + type OrderAcceptanceMutation = ( + &'static str, + fn(&mut RadrootsSp1TradeOrderAcceptanceWitness), + ); + type PublicValuesMutation = ( + &'static str, + fn(&mut super::RadrootsSp1TradeProofPublicValues), + ); + fn witness() -> RadrootsSp1TradeOrderAcceptanceWitness { RadrootsSp1TradeOrderAcceptanceWitness { witness_version: RADROOTS_SP1_TRADE_WITNESS_VERSION, @@ -1353,7 +1362,7 @@ mod tests { RadrootsSp1TradeGuestError::DecisionNotAccepted ); - let binding_cases: [(&str, fn(&mut RadrootsSp1TradeOrderAcceptanceWitness)); 4] = [ + let binding_cases: [OrderAcceptanceMutation; 4] = [ ( "order_id", |input: &mut RadrootsSp1TradeOrderAcceptanceWitness| { @@ -1471,7 +1480,7 @@ mod tests { RadrootsSp1TradeGuestError::UnsupportedProtocolVersion ); - let hash_fields: [(&str, fn(&mut super::RadrootsSp1TradeProofPublicValues)); 12] = [ + let hash_fields: [PublicValuesMutation; 12] = [ ( "reducer_program_hash", |public_values: &mut super::RadrootsSp1TradeProofPublicValues| { @@ -1554,7 +1563,7 @@ mod tests { ); } - let event_id_fields: [(&str, fn(&mut super::RadrootsSp1TradeProofPublicValues)); 3] = [ + let event_id_fields: [PublicValuesMutation; 3] = [ ( "listing_event_id", |public_values: &mut super::RadrootsSp1TradeProofPublicValues| { diff --git a/crates/sp1_host_trade/src/lib.rs b/crates/sp1_host_trade/src/lib.rs @@ -1770,6 +1770,10 @@ mod tests { #[cfg(feature = "sp1_verify")] use serde::Deserialize; + type ProofEnvelopeMutation = (&'static str, fn(&mut super::RadrootsSp1TradeProofEnvelope)); + type PublicValuesExecutionMutation = + (&'static str, fn(&mut RadrootsSp1TradePublicValuesExecution)); + fn witness() -> RadrootsSp1TradeOrderAcceptanceWitness { RadrootsSp1TradeOrderAcceptanceWitness { witness_version: RADROOTS_SP1_TRADE_WITNESS_VERSION, @@ -2248,7 +2252,7 @@ mod tests { RadrootsSp1TradeHostError::PublicValuesHashMismatch ); - let envelope_cases: [(&str, fn(&mut super::RadrootsSp1TradeProofEnvelope)); 10] = [ + let envelope_cases: [ProofEnvelopeMutation; 10] = [ ( "receipt_type", |envelope: &mut super::RadrootsSp1TradeProofEnvelope| { @@ -2435,7 +2439,7 @@ mod tests { fn validation_receipt_requires_event_bindings() { let bundle = generate_order_acceptance_proof(&witness(), RadrootsSp1TradeProofMode::None) .expect("proof bundle"); - let cases: [(&str, fn(&mut RadrootsSp1TradePublicValuesExecution)); 3] = [ + let cases: [PublicValuesExecutionMutation; 3] = [ ("listing_event_id", |execution| { execution.public_values.listing_event_id = None; }), diff --git a/crates/sql_core/tests/coverage.rs b/crates/sql_core/tests/coverage.rs @@ -94,23 +94,21 @@ impl SqlExecutor for MockExecutor { fn exec(&self, sql: &str, params_json: &str) -> Result<ExecOutcome, SqlError> { let mut state = self.state.lock().expect("state"); state.exec_sql.push(sql.to_string()); - if let Some(needle) = &state.fail_sql_contains { - if sql.contains(needle) { - return Err(SqlError::InvalidQuery(sql.to_string())); - } + if let Some(needle) = &state.fail_sql_contains + && sql.contains(needle) + { + return Err(SqlError::InvalidQuery(sql.to_string())); } if sql.contains("insert or ignore into __migrations(name)") { - let params: Vec<String> = - serde_json::from_str(params_json).map_err(|err| SqlError::from(err))?; + let params: Vec<String> = serde_json::from_str(params_json).map_err(SqlError::from)?; if let Some(name) = params.first() { state.applied.insert(name.clone()); } } if sql.contains("delete from __migrations where name = ?") { - let params: Vec<String> = - serde_json::from_str(params_json).map_err(|err| SqlError::from(err))?; + let params: Vec<String> = serde_json::from_str(params_json).map_err(SqlError::from)?; if let Some(name) = params.first() { state.applied.remove(name); } @@ -127,8 +125,7 @@ impl SqlExecutor for MockExecutor { if let Some(override_value) = &state.query_override { return override_value.clone(); } - let params: Vec<String> = - serde_json::from_str(params_json).map_err(|err| SqlError::from(err))?; + let params: Vec<String> = serde_json::from_str(params_json).map_err(SqlError::from)?; let Some(name) = params.first() else { return Ok(String::new()); }; diff --git a/crates/trade/src/order.rs b/crates/trade/src/order.rs @@ -272,6 +272,7 @@ pub struct RadrootsOrderProjectionQueryResult { } #[derive(Clone, Debug, PartialEq, Eq)] +#[allow(clippy::large_enum_variant)] pub enum RadrootsTradeLocatorProjectionResolution { Missing { locator: RadrootsTradeLocator, diff --git a/crates/trade/src/projection.rs b/crates/trade/src/projection.rs @@ -470,6 +470,7 @@ async fn upsert_trade_projection( Ok(upserts) } +#[allow(clippy::too_many_arguments)] async fn upsert_trade_projection_row( store: &RadrootsEventStore, order_id: &RadrootsOrderId, diff --git a/crates/trade/src/validation_receipt.rs b/crates/trade/src/validation_receipt.rs @@ -1034,8 +1034,8 @@ mod tests { #[test] fn validation_trust_policy_builders_preserve_explicit_settings() { - let trusted = RadrootsPublicKey::parse(&event_id('a')).unwrap(); - let other = RadrootsPublicKey::parse(&event_id('b')).unwrap(); + let trusted = RadrootsPublicKey::parse(event_id('a')).unwrap(); + let other = RadrootsPublicKey::parse(event_id('b')).unwrap(); let policy = RadrootsTradeValidationTrustPolicy::production() .with_trusted_rhi_pubkeys(vec![trusted.clone()]) .with_allow_deterministic_none(true) diff --git a/tools/xtask/src/contract.rs b/tools/xtask/src/contract.rs @@ -2161,12 +2161,10 @@ fn validate_knowledge_manifest_witnesses( .get("contract_id") .and_then(Value::as_str) .ok_or_else(|| "knowledge manifest entry missing contract_id".to_string())?; - if let Some(previous) = previous_id.as_deref() { - if previous > contract_id { - return Err( - "knowledge manifest contracts must be sorted by contract_id".to_string() - ); - } + if let Some(previous) = previous_id.as_deref() + && previous > contract_id + { + return Err("knowledge manifest contracts must be sorted by contract_id".to_string()); } previous_id = Some(contract_id.to_string()); if !ids.insert(contract_id.to_string()) { @@ -2194,12 +2192,12 @@ fn validate_knowledge_manifest_witnesses( let wasm_verified_decode_support = manifest_bool_field(contract, "wasm_verified_decode_support")?; - if KNOWLEDGE_MVP_SUPPORT_CONTRACT_IDS.contains(&contract_id) { - if !sdk_builder_support || !sdk_draft_support || !wasm_tag_builder_support { - return Err(format!( - "knowledge manifest MVP contract {contract_id} must report SDK and WASM tag support" - )); - } + if KNOWLEDGE_MVP_SUPPORT_CONTRACT_IDS.contains(&contract_id) + && (!sdk_builder_support || !sdk_draft_support || !wasm_tag_builder_support) + { + return Err(format!( + "knowledge manifest MVP contract {contract_id} must report SDK and WASM tag support" + )); } if KNOWLEDGE_BETA_CONTRACT_IDS.contains(&contract_id) && (sdk_builder_support || sdk_draft_support || wasm_tag_builder_support) @@ -2621,13 +2619,12 @@ fn validate_policy_metadata(policy: &Policy) -> Result<(), String> { { return Err("contract policy flags must all be true".to_string()); } - if let Some(replica) = &policy.replica { - if !replica.forbid_legacy_alias_identifiers + if let Some(replica) = &policy.replica + && (!replica.forbid_legacy_alias_identifiers || !replica.require_transport_agnostic_sync_contract - || !replica.require_deterministic_emit_ingest - { - return Err("contract replica policy flags must all be true".to_string()); - } + || !replica.require_deterministic_emit_ingest) + { + return Err("contract replica policy flags must all be true".to_string()); } Ok(()) } @@ -4418,7 +4415,7 @@ crates = ["radroots_a", "radroots_b", "radroots_c", "radroots_d", "radroots_e"] passing_coverage_row("radroots_e"), ], ); - let _ = fs::remove_file(root_release_policy_path(&root)); + let _ = fs::remove_file(root_release_policy_path(root)); } #[test] @@ -6006,8 +6003,8 @@ publish = false fn workspace_package_publish_configs_cover_success_and_duplicate_names() { let root = create_synthetic_workspace("workspace_publish_configs"); let flags = workspace_package_publish_flags(&root).expect("publish flags"); - assert_eq!(flags["radroots_a"], true); - assert_eq!(flags["radroots_b"], false); + assert!(flags["radroots_a"]); + assert!(!flags["radroots_b"]); let configs = workspace_package_publish_configs(&root).expect("publish configs"); assert_eq!(