chore: rust 1.89

Author: dsherret

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.85.0"
+channel = "1.89.0"
 components = ["clippy", "rustfmt"]

src/lib.rs

@@ -3,6 +3,7 @@
 #![deny(clippy::print_stderr)]
 #![deny(clippy::print_stdout)]
 #![deny(clippy::unused_async)]
+#![allow(mismatched_lifetime_syntaxes)]
 
 pub mod parser;
 

src/parser.rs

@@ -651,11 +651,10 @@ fn parse_unquoted_word(input: &str) -> ParseResult<Vec<WordPart>> {
       result
         .ok()
         .map(|(_, parts)| {
-          if parts.len() == 1 {
-            if let WordPart::Text(text) = &parts[0] {
+          if parts.len() == 1
+            && let WordPart::Text(text) = &parts[0] {
               return !is_reserved_word(text);
             }
-          }
           true
         })
         .unwrap_or(true)
@@ -1041,13 +1040,12 @@ fn assert_whitespace_or_end_and_skip(input: &str) -> ParseResult<()> {
 }
 
 fn assert_whitespace_or_end(input: &str) -> ParseResult<()> {
-  if let Some(next_char) = input.chars().next() {
-    if !next_char.is_whitespace()
+  if let Some(next_char) = input.chars().next()
+    && !next_char.is_whitespace()
       && !matches!(next_char, ';' | '&' | '|' | '(' | ')')
     {
       return Err(ParseError::Failure(fail_for_trailing_input(input)));
     }
-  }
   Ok((input, ()))
 }
 

src/shell/child_process_tracker.rs

@@ -39,11 +39,10 @@ impl ChildProcessTracker {
   }
 
   pub fn track(&self, child: &Child) {
-    if let Err(err) = self.0.track(child) {
-      if cfg!(debug_assertions) && child.id().is_some() {
+    if let Err(err) = self.0.track(child)
+      && cfg!(debug_assertions) && child.id().is_some() {
         panic!("Could not track process: {:#}", err);
       }
-    }
   }
 }
 

src/shell/command.rs

@@ -80,7 +80,7 @@ enum CommandName {
 
 struct ResolvedCommand<'a> {
   command_name: CommandName,
-  args: Cow<'a, Vec<OsString>>,
+  args: Cow<'a, [OsString]>,
 }
 
 #[derive(Error, Debug)]
@@ -111,7 +111,7 @@ impl FailedShebangError {
 async fn resolve_command<'a>(
   command_name: &UnresolvedCommandName,
   context: &ShellCommandContext,
-  original_args: &'a Vec<OsString>,
+  original_args: &'a [OsString],
 ) -> Result<ResolvedCommand<'a>, ResolveCommandError> {
   let command_path = match resolve_command_path(
     &command_name.name,
@@ -125,8 +125,8 @@ async fn resolve_command<'a>(
   // only bother checking for a shebang when the path has a slash
   // in it because for global commands someone on Windows likely
   // won't have a script with a shebang in it on Windows
-  if Path::new(&command_name.name).components().count() > 1 {
-    if let Some(shebang) = resolve_shebang(&command_path).map_err(|err| {
+  if Path::new(&command_name.name).components().count() > 1
+    && let Some(shebang) = resolve_shebang(&command_path).map_err(|err| {
       ResolveCommandError::FailedShebang(FailedShebangError::Any(err.into()))
     })? {
       let (shebang_command_name, mut args) = if shebang.string_split {
@@ -150,7 +150,6 @@ async fn resolve_command<'a>(
         args: Cow::Owned(args),
       });
     }
-  }
 
   Ok(ResolvedCommand {
     command_name: CommandName::Resolved(command_path),

src/shell/commands/rm.rs

@@ -62,15 +62,14 @@ async fn execute_remove(cwd: &Path, args: &[OsString]) -> Result<()> {
     } else {
       remove_file_or_dir(&path, &flags).await
     };
-    if let Err(err) = result {
-      if err.kind() != ErrorKind::NotFound || !flags.force {
+    if let Err(err) = result
+      && (err.kind() != ErrorKind::NotFound || !flags.force) {
         bail!(
           "cannot remove '{}': {}",
           specified_path.to_string_lossy(),
           err
         );
       }
-    }
   }
 
   Ok(())

src/shell/commands/xargs.rs

@@ -66,11 +66,10 @@ fn xargs_collect_args(
     args.extend(text.split(delimiter).map(|t| t.into()));
 
     // remove last arg if it is empty
-    if let Some(last) = args.last() {
-      if last.is_empty() {
+    if let Some(last) = args.last()
+      && last.is_empty() {
         args.pop();
       }
-    }
   } else {
     args.extend(delimit_blanks(&text)?);
   }

src/shell/types.rs

@@ -150,15 +150,14 @@ impl ShellState {
     };
     if name == "PWD" {
       let cwd = Path::new(value);
-      if cwd.is_absolute() {
-        if let Ok(cwd) = deno_path_util::fs::canonicalize_path_maybe_not_exists(
+      if cwd.is_absolute()
+        && let Ok(cwd) = deno_path_util::fs::canonicalize_path_maybe_not_exists(
           &sys_traits::impls::RealSys,
           cwd,
         ) {
           // this will update the environment variable too
           self.set_cwd(cwd);
         }
-      }
     } else {
       self.shell_vars.remove(&name);
       self.env_vars.insert(name, value.to_os_string());