rust/clippy: Lints for Defensive Programming — heartwood

Fixes for rust/clippy: Lints for Defensive Programming - 9584e6f. Added all suggested Clippy lints :).

 [workspace.lints]
 clippy.type_complexity = "allow"
 clippy.enum_variant_names = "allow"
 clippy.indexing_slicing = "deny"
 clippy.fallible_impl_from = "deny"
 clippy.wildcard_enum_match_arm = "deny"
 clippy.unneeded_field_pattern = "deny"
 clippy.fn_params_excessive_bools = "deny"
 clippy.must_use_candidate = "deny"
 [profile.container]
 inherits = "release"

             repo,
             objects,
             type_name,
             format: _,
             ..
         } => {
             let repo = storage.repository(repo)?;
             if let Err(e) = show(objects, &repo, type_name.into(), &profile) {

             type_name,
             object,
             operation,
             format: _,
             ..
         }) => {
             let signer = &profile.signer()?;
             let repo = storage.repository_mut(repo)?;

     chunks.map(|chunk| {
         // Slice accesses will not panic, guaranteed by `chunks_exact(2)`.
         #[allow(clippy::indexing_slicing)]
         Embed {
             name: chunk[0].to_string(),
             content: EmbedContent::from(T::from(chunk[1].clone())),

     let mut node = radicle::Node::new(profile.socket());
     match Operation::from(args) {
         Operation::Follow {
             nid,
             alias,
             verbose: _,
         } => follow(nid, alias, &mut node, &profile)?,
         Operation::List { alias, verbose: _ } => following(&profile, alias)?,
         Operation::Follow { nid, alias, .. } => follow(nid, alias, &mut node, &profile)?,
         Operation::List { alias, .. } => following(&profile, alias)?,
     }
     Ok(())

     chunks.map(|chunk| {
         // Slice accesses will not panic, guaranteed by `chunks_exact(3)`.
         #[allow(clippy::indexing_slicing)]
         Ok(PayloadUpsert {
             id: PayloadId::from_str(&chunk[0])?,
             key: chunk[1].to_owned(),

                 .spawn()?
                 .wait()?;
         }
         notification => {
         notification @ NotificationKind::Cob { .. }
         | notification @ NotificationKind::Unknown { .. } => {
             term::json::to_pretty(&notification, Path::new("notification.json"))?.print();
         }
     }

             // Special handling for `--edit` will be removed in the future.
             | Command::Edit { .. } => true,
             Command::Comment(args) => !args.is_edit(),
             _ => false,
             Command::Cache{..} | Command::Show { .. } | Command::List(_) => false,
         }
     }
 }

             (None, Some(react), None) => CommentAction::React {
                 revision,
                 comment: react,
                 emoji: emoji.unwrap(),
                 emoji: emoji.expect("emoji must be Some when react is Some"),
                 undo,
             },
             (None, None, Some(redact)) => CommentAction::Redact {

             Self::FileAdded { hunk, .. } => hunk.as_ref(),
             Self::FileDeleted { hunk, .. } => hunk.as_ref(),
             Self::FileModified { hunk, .. } => hunk.as_ref(),
             _ => None,
             Self::FileMoved { .. }
             | Self::FileCopied { .. }
             | Self::FileEofChanged { .. }
             | Self::FileModeChanged { .. } => None,
         }
     }

                 EofNewLine::OldMissing => {
                     VStack::default().child(term::Label::new("`\\n` added at end-of-file"))
                 }
                 _ => VStack::default(),
                 EofNewLine::BothMissing | EofNewLine::NoneMissing => VStack::default(),
             },
             Self::FileModeChanged { .. } => VStack::default(),
         }

 impl Rev {
     /// Return the revision as a string.
     #[must_use]
     pub fn as_str(&self) -> &str {
         &self.0
     }

     Ok(git_version)
 }
 /// Parse a remote refspec into a peer id and ref.
 pub fn parse_remote(refspec: &str) -> Option<(NodeId, &str)> {
     refspec
         .strip_prefix("refs/remotes/")
         .and_then(|s| s.split_once('/'))
         .and_then(|(peer, r)| NodeId::from_str(peer).ok().map(|p| (p, r)))
 }
 pub fn add_tag(
     repo: &Repository,
     message: &str,

     }
     /// Returns owned files in the diff.
     #[must_use]
     pub fn into_files(self) -> Vec<FileDDiff> {
         self.files
     }

         match self {
             Modification::Deletion(diff::Deletion { line, line_no }) => {
                 if let Some(lines) = &blobs.old.as_ref() {
                     lines[*line_no as usize - 1].clone()
                     lines.get(*line_no as usize - 1).unwrap().clone()
                 } else {
                     term::Line::new(String::from_utf8_lossy(line.as_bytes()).as_ref())
                 }
             }
             Modification::Addition(diff::Addition { line, line_no }) => {
                 if let Some(lines) = &blobs.new.as_ref() {
                     lines[*line_no as usize - 1].clone()
                     lines.get(*line_no as usize - 1).unwrap().clone()
                 } else {
                     term::Line::new(String::from_utf8_lossy(line.as_bytes()).as_ref())
                 }

         Self::Syntax(msg.to_string())
     }
     #[must_use]
     pub fn is_eof(&self) -> bool {
         match self {
             Self::UnexpectedEof => true,
             Self::Io(e) => e.kind() == io::ErrorKind::UnexpectedEof,
             _ => false,
             Self::Syntax(_) | Self::ParseInt(_) | Self::Utf8(_) => false,
         }
     }
 }

 }
 impl HunkHeader {
     #[must_use]
     pub fn old_line_range(&self) -> std::ops::Range<u32> {
         let start: u32 = self.old_line_no;
         let end: u32 = self.old_line_no + self.old_size;
         start..end + 1
     }
     #[must_use]
     pub fn new_line_range(&self) -> std::ops::Range<u32> {
         let start: u32 = self.new_line_no;
         let end: u32 = self.new_line_no + self.new_size;

         Ok(())
     }
     #[must_use]
     pub fn styled(mut self, value: bool) -> Self {
         self.styled = value;
         self

 impl SyncSettings {
     /// Set sync timeout. Defaults to [`DEFAULT_SYNC_TIMEOUT`].
     #[must_use]
     pub fn timeout(mut self, timeout: time::Duration) -> Self {
         self.timeout = timeout;
         self
     }
     /// Set replicas.
     #[must_use]
     pub fn replicas(mut self, replicas: sync::ReplicationFactor) -> Self {
         self.replicas = replicas;
         self

     /// Use profile to populate sync settings, by adding preferred seeds if no seeds are specified,
     /// and removing the local node from the set.
     #[must_use]
     pub fn with_profile(mut self, profile: &Profile) -> Self {
         // If no seeds were specified, add the preferred seeds.
         if self.seeds.is_empty() {

     fn is_connection_err(&self) -> bool {
         match self {
             Self::Node(e) => e.is_connection_err(),
             _ => false,
             Self::Repository(_) | Self::AllSeedsTimedOut | Self::Target(_) => false,
         }
     }
 }

     use super::MigrateSpinner;
     /// Display migration progress via a spinner.
     #[must_use]
     pub fn spinner() -> MigrateSpinner {
         MigrateSpinner::default()
     }

 /// Adds a hint to the COB out-of-date database error.
 fn with_hint(e: profile::Error) -> anyhow::Error {
     // There are many types that aren't `profile::Error::CobsCache`; specifying them all in an
     // error path seems overly verbose with little value.
     #[allow(clippy::wildcard_enum_match_arm)]
     match e {
         profile::Error::CobsCache(cob::cache::Error::OutOfDate) => {
             anyhow::Error::from(terminal::args::Error::WithHint {

 use crate::terminal as term;
 /// Format a node id to be more compact.
 #[must_use]
 pub fn node_id_human_compact(node: &NodeId) -> Paint<String> {
     let node = node.to_human();
     let start = node.chars().take(7).collect::<String>();

 }
 /// Format a node id.
 #[must_use]
 pub fn node_id_human(node: &NodeId) -> Paint<String> {
     Paint::new(node.to_human())
 }
 #[must_use]
 pub fn addr_compact(address: &Address) -> Paint<String> {
     let host = match address.host() {
         HostName::Ip(ip) => ip.to_string(),

 }
 /// Format a COB id.
 #[must_use]
 pub fn cob(id: &ObjectId) -> Paint<String> {
     Paint::new(format!("{:.7}", id.to_string()))
 }
 /// Format a DID.
 #[must_use]
 pub fn did(did: &Did) -> Paint<String> {
     let nid = did.as_key().to_human();
     Paint::new(format!("{}…{}", &nid[..7], &nid[nid.len() - 7..]))
 }
 /// Format a Visibility.
 #[must_use]
 pub fn visibility(v: &Visibility) -> Paint<&str> {
     match v {
         Visibility::Public => term::format::positive("public"),

 }
 /// Format a policy.
 #[must_use]
 pub fn policy(p: &Policy) -> Paint<String> {
     match p {
         Policy::Allow => term::format::positive(p.to_string()),

     Paint::new(fmt.convert(duration.into()))
 }
 #[must_use]
 pub fn bytes(size: usize) -> Paint<String> {
     const KB: usize = 1024;
     const MB: usize = 1024usize.pow(2);

 }
 /// Format a ref update.
 #[must_use]
 pub fn ref_update(update: &RefUpdate) -> Paint<&'static str> {
     match update {
         RefUpdate::Updated { .. } => term::format::tertiary("updated"),

         }
     }
     #[must_use]
     pub fn short(mut self) -> Self {
         self.short = true;
         self
     }
     #[must_use]
     pub fn styled(mut self) -> Self {
         self.styled = true;
         self

 }
 impl<'a> Author<'a> {
     #[must_use]
     pub fn new(nid: &'a NodeId, profile: &Profile, verbose: bool) -> Author<'a> {
         let alias = profile.alias(nid);

         }
     }
     #[must_use]
     pub fn alias(&self) -> Option<term::Label> {
         self.alias.as_ref().map(|a| a.to_string().into())
     }
     #[must_use]
     pub fn you(&self) -> Option<term::Label> {
         if self.you {
             Some(term::format::primary("(you)").dim().italic().into())

     ///   * `(<did>, (you))` -- the `Author` is the local peer and has no alias
     ///   * `(<alias>, <did>)` -- the `Author` is another peer and has an alias
     ///   * `(<blank>, <did>)` -- the `Author` is another peer and has no alias
     #[must_use]
     pub fn labels(self) -> (term::Label, term::Label) {
         let node_id = if self.verbose {
             term::format::node_id_human(self.nid)

         (alias, author)
     }
     #[must_use]
     pub fn line(self) -> Line {
         let (alias, author) = self.labels();
         Line::spaced([alias, author])

 /// HTML-related formatting.
 pub mod html {
     /// Comment a string with HTML comments.
     #[must_use]
     pub fn commented(s: &str) -> String {
         format!("<!--\n{s}\n-->")
     }