lint: Fix all issues in preparation for enabling clippy::if_not_else

src/uu/base32/src/base_common.rs

@@ -160,18 +160,7 @@ pub fn handle_input<R: Read>(
         data = data.line_wrap(wrap);
     }
 
-    if !decode {
+    if decode {
-        match data.encode() {
-            Ok(s) => {
-                wrap_print(&data, &s);
-                Ok(())
-            }
-            Err(_) => Err(USimpleError::new(
-                1,
-                "error: invalid input (length must be multiple of 4 characters)",
-            )),
-        }
-    } else {
         match data.decode() {
             Ok(s) => {
                 // Silent the warning as we want to the error message
@@ -184,5 +173,16 @@ pub fn handle_input<R: Read>(
             }
             Err(_) => Err(USimpleError::new(1, "error: invalid input")),
         }
+    } else {
+        match data.encode() {
+            Ok(s) => {
+                wrap_print(&data, &s);
+                Ok(())
+            }
+            Err(_) => Err(USimpleError::new(
+                1,
+                "error: invalid input (length must be multiple of 4 characters)",
+            )),
+        }
     }
 }

src/uu/chmod/src/chmod.rs

@@ -274,10 +274,10 @@ impl Chmoder {
                     )
                 ));
             }
-            if !self.recursive {
+            if self.recursive {
-                r = self.chmod_file(file).and(r);
-            } else {
                 r = self.walk_dir(file);
+            } else {
+                r = self.chmod_file(file).and(r);
             }
         }
         r
@@ -360,10 +360,10 @@ impl Chmoder {
                             naively_expected_new_mode = naive_mode;
                         }
                         Err(f) => {
-                            if !self.quiet {
+                            if self.quiet {
-                                return Err(USimpleError::new(1, f));
-                            } else {
                                 return Err(ExitCode::new(1));
+                            } else {
+                                return Err(USimpleError::new(1, f));
                             }
                         }
                     }

src/uu/chown/src/chown.rs

@@ -198,7 +198,9 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
     let user = args.next().unwrap_or("");
     let group = args.next().unwrap_or("");
 
-    let uid = if !user.is_empty() {
+    let uid = if user.is_empty() {
+        None
+    } else {
         Some(match Passwd::locate(user) {
             Ok(u) => u.uid, // We have been able to get the uid
             Err(_) =>
@@ -225,10 +227,10 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
                 }
             }
         })
-    } else {
-        None
     };
-    let gid = if !group.is_empty() {
+    let gid = if group.is_empty() {
+        None
+    } else {
         Some(match Group::locate(group) {
             Ok(g) => g.gid,
             Err(_) => match group.parse() {
@@ -241,8 +243,6 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
                 }
             },
         })
-    } else {
-        None
     };
 
     if user.chars().next().map(char::is_numeric).unwrap_or(false)

src/uu/date/src/date.rs

@@ -414,10 +414,10 @@ fn set_system_datetime(date: DateTime<Utc>) -> UResult<()> {
 
     let result = unsafe { clock_settime(CLOCK_REALTIME, &timespec) };
 
-    if result != 0 {
+    if result == 0 {
-        Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
-    } else {
         Ok(())
+    } else {
+        Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
     }
 }
 

src/uu/dd/src/dd.rs

@@ -265,10 +265,10 @@ fn make_linux_iflags(iflags: &IFlags) -> Option<libc::c_int> {
         flag |= libc::O_SYNC;
     }
 
-    if flag != 0 {
+    if flag == 0 {
-        Some(flag)
-    } else {
         None
+    } else {
+        Some(flag)
     }
 }
 
@@ -784,10 +784,10 @@ fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
         flag |= libc::O_SYNC;
     }
 
-    if flag != 0 {
+    if flag == 0 {
-        Some(flag)
-    } else {
         None
+    } else {
+        Some(flag)
     }
 }
 

src/uu/df/src/filesystem.rs

@@ -83,9 +83,7 @@ where
 impl Filesystem {
     // TODO: resolve uuid in `mount_info.dev_name` if exists
     pub(crate) fn new(mount_info: MountInfo, file: Option<String>) -> Option<Self> {
-        let _stat_path = if !mount_info.mount_dir.is_empty() {
+        let _stat_path = if mount_info.mount_dir.is_empty() {
-            mount_info.mount_dir.clone()
-        } else {
             #[cfg(unix)]
             {
                 mount_info.dev_name.clone()
@@ -95,6 +93,8 @@ impl Filesystem {
                 // On windows, we expect the volume id
                 mount_info.dev_id.clone()
             }
+        } else {
+            mount_info.mount_dir.clone()
         };
         #[cfg(unix)]
         let usage = FsUsage::new(statfs(_stat_path).ok()?);

src/uu/dirname/src/dirname.rs

@@ -38,7 +38,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(|s| s.to_owned())
         .collect();
 
-    if !dirnames.is_empty() {
+    if dirnames.is_empty() {
+        return Err(UUsageError::new(1, "missing operand"));
+    } else {
         for path in &dirnames {
             let p = Path::new(path);
             match p.parent() {
@@ -59,8 +61,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
             print!("{separator}");
         }
-    } else {
-        return Err(UUsageError::new(1, "missing operand"));
     }
 
     Ok(())

src/uu/env/src/env.rs

@@ -299,7 +299,10 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
         env::set_var(name, val);
     }
 
-    if !opts.program.is_empty() {
+    if opts.program.is_empty() {
+        // no program provided, so just dump all env vars to stdout
+        print_env(opts.null);
+    } else {
         // we need to execute a command
         let (prog, args) = build_command(&mut opts.program);
 
@@ -344,9 +347,6 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
             Err(_) => return Err(126.into()),
             Ok(_) => (),
         }
-    } else {
-        // no program provided, so just dump all env vars to stdout
-        print_env(opts.null);
     }
 
     Ok(())

src/uu/expr/src/syntax_tree.rs

@@ -185,14 +185,14 @@ pub fn tokens_to_ast(
 
         maybe_dump_rpn(&out_stack);
         let result = ast_from_rpn(&mut out_stack);
-        if !out_stack.is_empty() {
+        if out_stack.is_empty() {
+            maybe_dump_ast(&result);
+            result
+        } else {
             Err(
                 "syntax error (first RPN token does not represent the root of the expression AST)"
                     .to_owned(),
             )
-        } else {
-            maybe_dump_ast(&result);
-            result
         }
     })
 }

src/uu/factor/src/numeric/montgomery.rs

@@ -82,10 +82,10 @@ impl<T: DoubleInt> Montgomery<T> {
         // (x + n*m) / R
         // in case of overflow, this is (2¹²⁸ + xnm)/2⁶⁴ - n = xnm/2⁶⁴ + (2⁶⁴ - n)
         let y = T::from_double_width(xnm >> t_bits)
-            + if !overflow {
+            + if overflow {
-                T::zero()
-            } else {
                 n.wrapping_neg()
+            } else {
+                T::zero()
             };
 
         if y >= *n {
@@ -132,10 +132,10 @@ impl<T: DoubleInt> Arithmetic for Montgomery<T> {
         let (r, overflow) = a.overflowing_add(&b);
 
         // In case of overflow, a+b = 2⁶⁴ + r = (2⁶⁴ - n) + r (working mod n)
-        let r = if !overflow {
+        let r = if overflow {
-            r
-        } else {
             r + self.n.wrapping_neg()
+        } else {
+            r
         };
 
         // Normalize to [0; n[

src/uu/fmt/src/parasplit.rs

@@ -580,11 +580,11 @@ impl<'a> Iterator for WordSplit<'a> {
         // points to whitespace character OR end of string
         let mut word_nchars = 0;
         self.position = match self.string[word_start..].find(|x: char| {
-            if !x.is_whitespace() {
+            if x.is_whitespace() {
+                true
+            } else {
                 word_nchars += char_width(x);
                 false
-            } else {
-                true
             }
         }) {
             None => self.length,

src/uu/hostname/src/hostname.rs

@@ -41,10 +41,10 @@ mod wsa {
             let mut data = std::mem::MaybeUninit::<WSADATA>::uninit();
             WSAStartup(0x0202, data.as_mut_ptr())
         };
-        if err != 0 {
+        if err == 0 {
-            Err(io::Error::from_raw_os_error(err))
-        } else {
             Ok(WsaHandle(()))
+        } else {
+            Err(io::Error::from_raw_os_error(err))
         }
     }
 

src/uu/id/src/id.rs

@@ -203,9 +203,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     for i in 0..=users.len() {
-        let possible_pw = if !state.user_specified {
+        let possible_pw = if state.user_specified {
-            None
-        } else {
             match Passwd::locate(users[i].as_str()) {
                 Ok(p) => Some(p),
                 Err(_) => {
@@ -218,6 +216,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                     }
                 }
             }
+        } else {
+            None
         };
 
         // GNU's `id` does not support the flags: -p/-P/-A.

src/uu/install/src/install.rs

@@ -399,13 +399,13 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
         .unwrap_or("")
         .to_string();
 
-    let owner_id = if !owner.is_empty() {
+    let owner_id = if owner.is_empty() {
+        None
+    } else {
         match usr2uid(&owner) {
             Ok(u) => Some(u),
             Err(_) => return Err(InstallError::InvalidUser(owner.clone()).into()),
         }
-    } else {
-        None
     };
 
     let group = matches
@@ -414,13 +414,13 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
         .unwrap_or("")
         .to_string();
 
-    let group_id = if !group.is_empty() {
+    let group_id = if group.is_empty() {
+        None
+    } else {
         match grp2gid(&group) {
             Ok(g) => Some(g),
             Err(_) => return Err(InstallError::InvalidGroup(group.clone()).into()),
         }
-    } else {
-        None
     };
 
     Ok(Behavior {

src/uu/ls/src/ls.rs

@@ -2008,16 +2008,16 @@ fn enter_directory(
                     continue;
                 }
                 Ok(rd) => {
-                    if !listed_ancestors
+                    if listed_ancestors
                         .insert(FileInformation::from_path(&e.p_buf, e.must_dereference)?)
                     {
-                        out.flush()?;
-                        show!(LsError::AlreadyListedError(e.p_buf.clone()));
-                    } else {
                         writeln!(out, "\n{}:", e.p_buf.display())?;
                         enter_directory(e, rd, config, out, listed_ancestors)?;
                         listed_ancestors
                             .remove(&FileInformation::from_path(&e.p_buf, e.must_dereference)?);
+                    } else {
+                        out.flush()?;
+                        show!(LsError::AlreadyListedError(e.p_buf.clone()));
                     }
                 }
             }
@@ -2867,10 +2867,10 @@ fn display_file_name(
     // to get correct alignment from later calls to`display_grid()`.
     if config.context {
         if let Some(pad_count) = prefix_context {
-            let security_context = if !matches!(config.format, Format::Commas) {
+            let security_context = if matches!(config.format, Format::Commas) {
-                pad_left(&path.security_context, pad_count)
-            } else {
                 path.security_context.to_owned()
+            } else {
+                pad_left(&path.security_context, pad_count)
             };
             name = format!("{security_context} {name}");
             width += security_context.len() + 1;

src/uu/numfmt/src/format.rs

@@ -55,7 +55,7 @@ impl<'a> Iterator for WhitespaceSplitter<'a> {
                 .unwrap_or(field.len()),
         );
 
-        self.s = if !rest.is_empty() { Some(rest) } else { None };
+        self.s = if rest.is_empty() { None } else { Some(rest) };
 
         Some((prefix, field))
     }

src/uu/numfmt/src/options.rs

@@ -190,14 +190,12 @@ impl FromStr for FormatOptions {
                 }
             }
 
-            if !precision.is_empty() {
+            if precision.is_empty() {
-                if let Ok(p) = precision.parse() {
-                    options.precision = Some(p);
-                } else {
-                    return Err(format!("invalid precision in format '{s}'"));
-                }
-            } else {
                 options.precision = Some(0);
+            } else if let Ok(p) = precision.parse() {
+                options.precision = Some(p);
+            } else {
+                return Err(format!("invalid precision in format '{s}'"));
             }
         }
 

src/uu/od/src/od.rs

@@ -171,12 +171,7 @@ impl OdOptions {
             None => Radix::Octal,
             Some(s) => {
                 let st = s.as_bytes();
-                if st.len() != 1 {
+                if st.len() == 1 {
-                    return Err(USimpleError::new(
-                        1,
-                        "Radix must be one of [d, o, n, x]".to_string(),
-                    ));
-                } else {
                     let radix: char = *(st
                         .first()
                         .expect("byte string of length 1 lacks a 0th elem"))
@@ -193,6 +188,11 @@ impl OdOptions {
                             ))
                         }
                     }
+                } else {
+                    return Err(USimpleError::new(
+                        1,
+                        "Radix must be one of [d, o, n, x]".to_string(),
+                    ));
                 }
             }
         };

src/uu/pinky/src/pinky.rs

@@ -218,10 +218,10 @@ impl Capitalize for str {
     fn capitalize(&self) -> String {
         self.char_indices()
             .fold(String::with_capacity(self.len()), |mut acc, x| {
-                if x.0 != 0 {
+                if x.0 == 0 {
-                    acc.push(x.1);
-                } else {
                     acc.push(x.1.to_ascii_uppercase());
+                } else {
+                    acc.push(x.1);
                 }
                 acc
             })
@@ -281,10 +281,10 @@ impl Pinky {
         match pts_path.metadata() {
             #[allow(clippy::unnecessary_cast)]
             Ok(meta) => {
-                mesg = if meta.mode() & S_IWGRP as u32 != 0 {
+                mesg = if meta.mode() & S_IWGRP as u32 == 0 {
-                    ' '
-                } else {
                     '*'
+                } else {
+                    ' '
                 };
                 last_change = meta.atime();
             }
@@ -312,10 +312,10 @@ impl Pinky {
         print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
 
         if self.include_idle {
-            if last_change != 0 {
+            if last_change == 0 {
-                print!(" {:<6}", idle_string(last_change));
-            } else {
                 print!(" {:<6}", "?????");
+            } else {
+                print!(" {:<6}", idle_string(last_change));
             }
         }
 

src/uu/rm/src/rm.rs

@@ -257,14 +257,14 @@ fn remove(files: &[String], options: &Options) -> bool {
                 // TODO: When the error is not about missing files
                 // (e.g., permission), even rm -f should fail with
                 // outputting the error, but there's no easy eay.
-                if !options.force {
+                if options.force {
+                    false
+                } else {
                     show_error!(
                         "cannot remove {}: No such file or directory",
                         filename.quote()
                     );
                     true
-                } else {
-                    false
                 }
             }
         }

src/uu/sort/src/merge.rs

@@ -362,16 +362,16 @@ impl<'a> Compare<MergeableFile> for FileComparator<'a> {
 
 // Wait for the child to exit and check its exit code.
 fn check_child_success(mut child: Child, program: &str) -> UResult<()> {
-    if !matches!(
+    if matches!(
         child.wait().map(|e| e.code()),
         Ok(Some(0)) | Ok(None) | Err(_)
     ) {
+        Ok(())
+    } else {
         Err(SortError::CompressProgTerminatedAbnormally {
             prog: program.to_owned(),
         }
         .into())
-    } else {
-        Ok(())
     }
 }
 

src/uu/sort/src/numeric_str_cmp.rs

@@ -198,15 +198,13 @@ pub fn human_numeric_str_cmp(
     let a_unit = get_unit(a.chars().next_back());
     let b_unit = get_unit(b.chars().next_back());
     let ordering = a_unit.cmp(&b_unit);
-    if ordering != Ordering::Equal {
+    if ordering == Ordering::Equal {
-        if a_info.sign == Sign::Negative {
-            ordering.reverse()
-        } else {
-            ordering
-        }
-    } else {
         // 3. Number
         numeric_str_cmp((a, a_info), (b, b_info))
+    } else if a_info.sign == Sign::Negative {
+        ordering.reverse()
+    } else {
+        ordering
     }
 }
 

src/uu/sort/src/sort.rs

@@ -185,7 +185,9 @@ impl Display for SortError {
                 line,
                 silent,
             } => {
-                if !silent {
+                if *silent {
+                    Ok(())
+                } else {
                     write!(
                         f,
                         "{}:{}: disorder: {}",
@@ -193,8 +195,6 @@ impl Display for SortError {
                         line_number,
                         line
                     )
-                } else {
-                    Ok(())
                 }
             }
             Self::OpenFailed { path, error } => {
@@ -582,7 +582,15 @@ impl<'a> Line<'a> {
                     selection.start += num_range.start;
                     selection.end = selection.start + num_range.len();
 
-                    if num_range != (0..0) {
+                    if num_range == (0..0) {
+                        // This was not a valid number.
+                        // Report no match at the first non-whitespace character.
+                        let leading_whitespace = self.line[selection.clone()]
+                            .find(|c: char| !c.is_whitespace())
+                            .unwrap_or(0);
+                        selection.start += leading_whitespace;
+                        selection.end += leading_whitespace;
+                    } else {
                         // include a trailing si unit
                         if selector.settings.mode == SortMode::HumanNumeric
                             && self.line[selection.end..initial_selection.end]
@@ -597,14 +605,6 @@ impl<'a> Line<'a> {
                         {
                             selection.start -= 1;
                         }
-                    } else {
-                        // This was not a valid number.
-                        // Report no match at the first non-whitespace character.
-                        let leading_whitespace = self.line[selection.clone()]
-                            .find(|c: char| !c.is_whitespace())
-                            .unwrap_or(0);
-                        selection.start += leading_whitespace;
-                        selection.end += leading_whitespace;
                     }
                 }
                 SortMode::GeneralNumeric => {
@@ -1572,10 +1572,7 @@ fn compare_by<'a>(
     let mut num_info_index = 0;
     let mut parsed_float_index = 0;
     for selector in &global_settings.selectors {
-        let (a_str, b_str) = if !selector.needs_selection {
+        let (a_str, b_str) = if selector.needs_selection {
-            // We can select the whole line.
-            (a.line, b.line)
-        } else {
             let selections = (
                 a_line_data.selections
                     [a.index * global_settings.precomputed.selections_per_line + selection_index],
@@ -1584,6 +1581,9 @@ fn compare_by<'a>(
             );
             selection_index += 1;
             selections
+        } else {
+            // We can select the whole line.
+            (a.line, b.line)
         };
 
         let settings = &selector.settings;

src/uu/split/src/number.rs

@@ -200,10 +200,10 @@ impl FixedWidthNumber {
                 break;
             }
         }
-        if suffix_start != 0 {
+        if suffix_start == 0 {
-            Err(Overflow)
-        } else {
             Ok(Self { radix, digits })
+        } else {
+            Err(Overflow)
         }
     }
 

src/uu/stat/src/stat.rs

@@ -375,9 +375,7 @@ impl Stater {
                     });
                 }
                 '\\' => {
-                    if !use_printf {
+                    if use_printf {
-                        tokens.push(Token::Char('\\'));
-                    } else {
                         i += 1;
                         if i >= bound {
                             show_warning!("backslash at end of format");
@@ -414,6 +412,8 @@ impl Stater {
                                 tokens.push(Token::Char(c));
                             }
                         }
+                    } else {
+                        tokens.push(Token::Char('\\'));
                     }
                 }
 
@@ -519,7 +519,67 @@ impl Stater {
             OsString::from(file)
         };
 
-        if !self.show_fs {
+        if self.show_fs {
+            #[cfg(unix)]
+            let p = file.as_bytes();
+            #[cfg(not(unix))]
+            let p = file.into_string().unwrap();
+            match statfs(p) {
+                Ok(meta) => {
+                    let tokens = &self.default_tokens;
+
+                    for t in tokens.iter() {
+                        match *t {
+                            Token::Char(c) => print!("{c}"),
+                            Token::Directive {
+                                flag,
+                                width,
+                                precision,
+                                format,
+                            } => {
+                                let output = match format {
+                                    // free blocks available to non-superuser
+                                    'a' => OutputType::Unsigned(meta.avail_blocks()),
+                                    // total data blocks in file system
+                                    'b' => OutputType::Unsigned(meta.total_blocks()),
+                                    // total file nodes in file system
+                                    'c' => OutputType::Unsigned(meta.total_file_nodes()),
+                                    // free file nodes in file system
+                                    'd' => OutputType::Unsigned(meta.free_file_nodes()),
+                                    // free blocks in file system
+                                    'f' => OutputType::Unsigned(meta.free_blocks()),
+                                    // file system ID in hex
+                                    'i' => OutputType::UnsignedHex(meta.fsid()),
+                                    // maximum length of filenames
+                                    'l' => OutputType::Unsigned(meta.namelen()),
+                                    // file name
+                                    'n' => OutputType::Str(display_name.to_string()),
+                                    // block size (for faster transfers)
+                                    's' => OutputType::Unsigned(meta.io_size()),
+                                    // fundamental block size (for block counts)
+                                    'S' => OutputType::Integer(meta.block_size()),
+                                    // file system type in hex
+                                    't' => OutputType::UnsignedHex(meta.fs_type() as u64),
+                                    // file system type in human readable form
+                                    'T' => OutputType::Str(pretty_fstype(meta.fs_type()).into()),
+                                    _ => OutputType::Unknown,
+                                };
+
+                                print_it(&output, flag, width, precision);
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    show_error!(
+                        "cannot read file system information for {}: {}",
+                        display_name.quote(),
+                        e
+                    );
+                    return 1;
+                }
+            }
+        } else {
             let result = if self.follow || stdin_is_fifo && display_name == "-" {
                 fs::metadata(&file)
             } else {
@@ -660,66 +720,6 @@ impl Stater {
                     return 1;
                 }
             }
-        } else {
-            #[cfg(unix)]
-            let p = file.as_bytes();
-            #[cfg(not(unix))]
-            let p = file.into_string().unwrap();
-            match statfs(p) {
-                Ok(meta) => {
-                    let tokens = &self.default_tokens;
-
-                    for t in tokens.iter() {
-                        match *t {
-                            Token::Char(c) => print!("{c}"),
-                            Token::Directive {
-                                flag,
-                                width,
-                                precision,
-                                format,
-                            } => {
-                                let output = match format {
-                                    // free blocks available to non-superuser
-                                    'a' => OutputType::Unsigned(meta.avail_blocks()),
-                                    // total data blocks in file system
-                                    'b' => OutputType::Unsigned(meta.total_blocks()),
-                                    // total file nodes in file system
-                                    'c' => OutputType::Unsigned(meta.total_file_nodes()),
-                                    // free file nodes in file system
-                                    'd' => OutputType::Unsigned(meta.free_file_nodes()),
-                                    // free blocks in file system
-                                    'f' => OutputType::Unsigned(meta.free_blocks()),
-                                    // file system ID in hex
-                                    'i' => OutputType::UnsignedHex(meta.fsid()),
-                                    // maximum length of filenames
-                                    'l' => OutputType::Unsigned(meta.namelen()),
-                                    // file name
-                                    'n' => OutputType::Str(display_name.to_string()),
-                                    // block size (for faster transfers)
-                                    's' => OutputType::Unsigned(meta.io_size()),
-                                    // fundamental block size (for block counts)
-                                    'S' => OutputType::Integer(meta.block_size()),
-                                    // file system type in hex
-                                    't' => OutputType::UnsignedHex(meta.fs_type() as u64),
-                                    // file system type in human readable form
-                                    'T' => OutputType::Str(pretty_fstype(meta.fs_type()).into()),
-                                    _ => OutputType::Unknown,
-                                };
-
-                                print_it(&output, flag, width, precision);
-                            }
-                        }
-                    }
-                }
-                Err(e) => {
-                    show_error!(
-                        "cannot read file system information for {}: {}",
-                        display_name.quote(),
-                        e
-                    );
-                    return 1;
-                }
-            }
         }
         0
     }

src/uu/tail/src/chunks.rs

@@ -579,16 +579,16 @@ impl LinesChunkBuffer {
             }
         }
 
-        if !&self.chunks.is_empty() {
+        if self.chunks.is_empty() {
+            // chunks is empty when a file is empty so quitting early here
+            return Ok(());
+        } else {
             let length = &self.chunks.len();
             let last = &mut self.chunks[length - 1];
             if !last.get_buffer().ends_with(&[self.delimiter]) {
                 last.lines += 1;
                 self.lines += 1;
             }
-        } else {
-            // chunks is empty when a file is empty so quitting early here
-            return Ok(());
         }
 
         // skip unnecessary chunks and save the first chunk which may hold some lines we have to

src/uu/tail/src/tail.rs

@@ -125,10 +125,10 @@ fn tail_file(
 
         show_error!("error reading '{}': {}", input.display_name, err_msg);
         if settings.follow.is_some() {
-            let msg = if !settings.retry {
+            let msg = if settings.retry {
-                "; giving up on this name"
-            } else {
                 ""
+            } else {
+                "; giving up on this name"
             };
             show_error!(
                 "{}: cannot follow end of this type of file{}",
@@ -215,11 +215,7 @@ fn tail_stdin(
         // pipe
         None => {
             header_printer.print_input(input);
-            if !paths::stdin_is_bad_fd() {
+            if paths::stdin_is_bad_fd() {
-                let mut reader = BufReader::new(stdin());
-                unbounded_tail(&mut reader, settings)?;
-                observer.add_stdin(input.display_name.as_str(), Some(Box::new(reader)), true)?;
-            } else {
                 set_exit_code(1);
                 show_error!(
                     "cannot fstat {}: {}",
@@ -233,6 +229,10 @@ fn tail_stdin(
                         text::BAD_FD
                     );
                 }
+            } else {
+                let mut reader = BufReader::new(stdin());
+                unbounded_tail(&mut reader, settings)?;
+                observer.add_stdin(input.display_name.as_str(), Some(Box::new(reader)), true)?;
             }
         }
     };

src/uu/tee/src/tee.rs

@@ -261,11 +261,11 @@ fn process_error(
             Err(f)
         }
         Some(OutputErrorMode::ExitNoPipe) => {
-            if f.kind() != ErrorKind::BrokenPipe {
+            if f.kind() == ErrorKind::BrokenPipe {
+                Ok(())
+            } else {
                 show_error!("{}: {}", writer.name.maybe_quote(), f);
                 Err(f)
-            } else {
-                Ok(())
             }
         }
     }

src/uu/users/src/users.rs

@@ -41,10 +41,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(|v| v.map(AsRef::as_ref).collect())
         .unwrap_or_default();
 
-    let filename = if !files.is_empty() {
+    let filename = if files.is_empty() {
-        files[0]
-    } else {
         utmpx::DEFAULT_FILE.as_ref()
+    } else {
+        files[0]
     };
 
     let mut users = Utmpx::iter_all_records_from(filename)

src/uu/who/src/who.rs

@@ -316,13 +316,13 @@ fn time_string(ut: &Utmpx) -> String {
 fn current_tty() -> String {
     unsafe {
         let res = ttyname(STDIN_FILENO);
-        if !res.is_null() {
+        if res.is_null() {
+            String::new()
+        } else {
             CStr::from_ptr(res as *const _)
                 .to_string_lossy()
                 .trim_start_matches("/dev/")
                 .to_owned()
-        } else {
-            String::new()
         }
     }
 }
@@ -402,7 +402,7 @@ impl Who {
             &time_string(ut),
             "",
             "",
-            if !last.is_control() { &comment } else { "" },
+            if last.is_control() { "" } else { &comment },
             "",
         );
     }
@@ -482,7 +482,7 @@ impl Who {
                 let iwgrp = S_IWGRP;
                 #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))]
                 let iwgrp = S_IWGRP as u32;
-                mesg = if meta.mode() & iwgrp != 0 { '+' } else { '-' };
+                mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' };
                 last_change = meta.atime();
             }
             _ => {
@@ -491,10 +491,10 @@ impl Who {
             }
         }
 
-        let idle = if last_change != 0 {
+        let idle = if last_change == 0 {
-            idle_string(last_change, 0)
-        } else {
             "  ?".into()
+        } else {
+            idle_string(last_change, 0)
         };
 
         let s = if self.do_lookup {

src/uucore/src/lib/features/encoding.rs

@@ -67,10 +67,10 @@ pub fn encode(f: Format, input: &[u8]) -> Result<String, EncodeError> {
         Z85 => {
             // According to the spec we should not accept inputs whose len is not a multiple of 4.
             // However, the z85 crate implements a padded encoding and accepts such inputs. We have to manually check for them.
-            if input.len() % 4 != 0 {
+            if input.len() % 4 == 0 {
-                return Err(EncodeError::Z85InputLenNotMultipleOf4);
-            } else {
                 z85::encode(input)
+            } else {
+                return Err(EncodeError::Z85InputLenNotMultipleOf4);
             }
         }
     })

src/uucore/src/lib/features/entries.rs

@@ -168,10 +168,10 @@ pub struct Passwd {
 /// SAFETY: ptr must point to a valid C string.
 /// Returns None if ptr is null.
 unsafe fn cstr2string(ptr: *const c_char) -> Option<String> {
-    if !ptr.is_null() {
+    if ptr.is_null() {
-        Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
-    } else {
         None
+    } else {
+        Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
     }
 }
 

src/uucore/src/lib/features/fs.rs

@@ -455,6 +455,8 @@ pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) ->
     display_permissions_unix(mode, display_file_type)
 }
 
+// The logic below is more readable written this way.
+#[allow(clippy::if_not_else)]
 #[cfg(unix)]
 /// Display the permissions of a file on a unix like system
 pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String {

src/uucore/src/lib/features/fsext.rs

@@ -295,10 +295,10 @@ impl MountInfo {
                 fs_type_buf.len() as u32,
             )
         };
-        let fs_type = if 0 != success {
+        let fs_type = if 0 == success {
-            Some(LPWSTR2String(&fs_type_buf))
-        } else {
             None
+        } else {
+            Some(LPWSTR2String(&fs_type_buf))
         };
         let mut mn_info = Self {
             dev_id: volume_name,
@@ -862,10 +862,10 @@ pub fn pretty_time(sec: i64, nsec: i64) -> String {
 pub fn pretty_filetype<'a>(mode: mode_t, size: u64) -> &'a str {
     match mode & S_IFMT {
         S_IFREG => {
-            if size != 0 {
+            if size == 0 {
-                "regular file"
-            } else {
                 "regular empty file"
+            } else {
+                "regular file"
             }
         }
         S_IFDIR => "directory",

src/uucore/src/lib/features/perms.rs

@@ -263,10 +263,10 @@ impl ChownExecutor {
             0
         };
 
-        if !self.recursive {
+        if self.recursive {
-            ret
-        } else {
             ret | self.dive_into(&root)
+        } else {
+            ret
         }
     }
 

src/uucore/src/lib/features/process.rs

@@ -58,10 +58,10 @@ pub trait ChildExt {
 
 impl ChildExt for Child {
     fn send_signal(&mut self, signal: usize) -> io::Result<()> {
-        if unsafe { libc::kill(self.id() as pid_t, signal as i32) } != 0 {
+        if unsafe { libc::kill(self.id() as pid_t, signal as i32) } == 0 {
-            Err(io::Error::last_os_error())
-        } else {
             Ok(())
+        } else {
+            Err(io::Error::last_os_error())
         }
     }
 
@@ -70,10 +70,10 @@ impl ChildExt for Child {
         if unsafe { libc::signal(signal as i32, libc::SIG_IGN) } != 0 {
             return Err(io::Error::last_os_error());
         }
-        if unsafe { libc::kill(0, signal as i32) } != 0 {
+        if unsafe { libc::kill(0, signal as i32) } == 0 {
-            Err(io::Error::last_os_error())
-        } else {
             Ok(())
+        } else {
+            Err(io::Error::last_os_error())
         }
     }
 

src/uucore/src/lib/features/tokenize/sub.rs

@@ -197,30 +197,7 @@ impl SubParser {
             self.text_so_far.push(ch);
             match ch {
                 '-' | '*' | '0'..='9' => {
-                    if !self.past_decimal {
+                    if self.past_decimal {
-                        if self.min_width_is_asterisk || self.specifiers_found {
-                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                        }
-                        if self.min_width_tmp.is_none() {
-                            self.min_width_tmp = Some(String::new());
-                        }
-                        match self.min_width_tmp.as_mut() {
-                            Some(x) => {
-                                if (ch == '-' || ch == '*') && !x.is_empty() {
-                                    return Err(
-                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
-                                    );
-                                }
-                                if ch == '*' {
-                                    self.min_width_is_asterisk = true;
-                                }
-                                x.push(ch);
-                            }
-                            None => {
-                                panic!("should be unreachable");
-                            }
-                        }
-                    } else {
                         // second field should never have a
                         // negative value
                         if self.second_field_is_asterisk || ch == '-' || self.specifiers_found {
@@ -245,13 +222,36 @@ impl SubParser {
                                 panic!("should be unreachable");
                             }
                         }
+                    } else {
+                        if self.min_width_is_asterisk || self.specifiers_found {
+                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
+                        }
+                        if self.min_width_tmp.is_none() {
+                            self.min_width_tmp = Some(String::new());
+                        }
+                        match self.min_width_tmp.as_mut() {
+                            Some(x) => {
+                                if (ch == '-' || ch == '*') && !x.is_empty() {
+                                    return Err(
+                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
+                                    );
+                                }
+                                if ch == '*' {
+                                    self.min_width_is_asterisk = true;
+                                }
+                                x.push(ch);
+                            }
+                            None => {
+                                panic!("should be unreachable");
+                            }
+                        }
                     }
                 }
                 '.' => {
-                    if !self.past_decimal {
+                    if self.past_decimal {
-                        self.past_decimal = true;
-                    } else {
                         return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
+                    } else {
+                        self.past_decimal = true;
                     }
                 }
                 x if legal_fields.binary_search(&x).is_ok() => {

src/uucore/src/lib/features/tokenize/unescaped_text.rs

@@ -135,13 +135,13 @@ impl UnescapedText {
                     }
                     _ => {}
                 }
-                if !ignore {
+                if ignore {
+                    byte_vec.push(ch as u8);
+                } else {
                     let val = (Self::base_to_u32(min_len, max_len, base, it) % 256) as u8;
                     byte_vec.push(val);
                     let bvec = [val];
                     flush_bytes(writer, &bvec);
-                } else {
-                    byte_vec.push(ch as u8);
                 }
             }
             e => {

src/uucore/src/lib/features/utmpx.rs

@@ -336,7 +336,9 @@ impl Iterator for UtmpxIter {
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
             let res = getutxent();
-            if !res.is_null() {
+            if res.is_null() {
+                None
+            } else {
                 // The data behind this pointer will be replaced by the next
                 // call to getutxent(), so we have to read it now.
                 // All the strings live inline in the struct as arrays, which
@@ -344,8 +346,6 @@ impl Iterator for UtmpxIter {
                 Some(Utmpx {
                     inner: ptr::read(res as *const _),
                 })
-            } else {
-                None
             }
         }
     }

src/uucore/src/lib/mods/quoting_style.rs

@@ -259,13 +259,13 @@ fn shell_with_escape(name: &str, quotes: Quotes) -> (String, bool) {
 pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> String {
     match style {
         QuotingStyle::Literal { show_control } => {
-            if !show_control {
+            if *show_control {
+                name.to_string_lossy().into_owned()
+            } else {
                 name.to_string_lossy()
                     .chars()
                     .flat_map(|c| EscapedChar::new_literal(c).hide_control())
                     .collect()
-            } else {
-                name.to_string_lossy().into_owned()
             }
         }
         QuotingStyle::C { quotes } => {

src/uucore/src/lib/parser/parse_size.rs

@@ -70,13 +70,13 @@ impl<'parser> Parser<'parser> {
         // Get the numeric part of the size argument. For example, if the
         // argument is "123K", then the numeric part is "123".
         let numeric_string: String = size.chars().take_while(|c| c.is_ascii_digit()).collect();
-        let number: u64 = if !numeric_string.is_empty() {
+        let number: u64 = if numeric_string.is_empty() {
+            1
+        } else {
             match numeric_string.parse() {
                 Ok(n) => n,
                 Err(_) => return Err(ParseSizeError::parse_failure(size)),
             }
-        } else {
-            1
         };
 
         // Get the alphabetic units part of the size argument and compute