format

Author: dsherret

src/parser.rs

@@ -652,9 +652,10 @@ fn parse_unquoted_word(input: &str) -> ParseResult<Vec<WordPart>> {
         .ok()
         .map(|(_, parts)| {
           if parts.len() == 1
-            && let WordPart::Text(text) = &parts[0] {
-              return !is_reserved_word(text);
-            }
+            && let WordPart::Text(text) = &parts[0]
+          {
+            return !is_reserved_word(text);
+          }
           true
         })
         .unwrap_or(true)
@@ -1042,10 +1043,10 @@ 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()
     && !next_char.is_whitespace()
-      && !matches!(next_char, ';' | '&' | '|' | '(' | ')')
-    {
-      return Err(ParseError::Failure(fail_for_trailing_input(input)));
-    }
+    && !matches!(next_char, ';' | '&' | '|' | '(' | ')')
+  {
+    return Err(ParseError::Failure(fail_for_trailing_input(input)));
+  }
   Ok((input, ()))
 }
 

src/shell/child_process_tracker.rs

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

src/shell/command.rs

@@ -128,28 +128,29 @@ async fn resolve_command<'a>(
   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 {
-        let mut args = parse_shebang_args(&shebang.command, context)
-          .await
-          .map_err(FailedShebangError::Any)?;
-        args.push(command_path.clone().into_os_string());
-        (args.remove(0), args)
-      } else {
-        (
-          shebang.command.into(),
-          vec![command_path.clone().into_os_string()],
-        )
-      };
-      args.extend(original_args.iter().cloned());
-      return Ok(ResolvedCommand {
-        command_name: CommandName::Unresolved(UnresolvedCommandName {
-          name: shebang_command_name,
-          base_dir: command_path.parent().unwrap().to_path_buf(),
-        }),
-        args: Cow::Owned(args),
-      });
-    }
+    })?
+  {
+    let (shebang_command_name, mut args) = if shebang.string_split {
+      let mut args = parse_shebang_args(&shebang.command, context)
+        .await
+        .map_err(FailedShebangError::Any)?;
+      args.push(command_path.clone().into_os_string());
+      (args.remove(0), args)
+    } else {
+      (
+        shebang.command.into(),
+        vec![command_path.clone().into_os_string()],
+      )
+    };
+    args.extend(original_args.iter().cloned());
+    return Ok(ResolvedCommand {
+      command_name: CommandName::Unresolved(UnresolvedCommandName {
+        name: shebang_command_name,
+        base_dir: command_path.parent().unwrap().to_path_buf(),
+      }),
+      args: Cow::Owned(args),
+    });
+  }
 
   Ok(ResolvedCommand {
     command_name: CommandName::Resolved(command_path),

src/shell/commands/rm.rs

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

src/shell/commands/xargs.rs

@@ -67,9 +67,10 @@ fn xargs_collect_args(
 
     // remove last arg if it is empty
     if let Some(last) = args.last()
-      && last.is_empty() {
-        args.pop();
-      }
+      && last.is_empty()
+    {
+      args.pop();
+    }
   } else {
     args.extend(delimit_blanks(&text)?);
   }

src/shell/types.rs

@@ -154,10 +154,11 @@ impl ShellState {
         && 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);
-        }
+        )
+      {
+        // 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());
@@ -268,24 +269,24 @@ impl ShellPipeReader {
   pub fn stdin() -> ShellPipeReader {
     #[cfg(unix)]
     pub fn dup_stdin_as_pipe_reader() -> std::io::PipeReader {
-        use std::os::fd::AsFd;
-        use std::os::fd::IntoRawFd;
-        use std::os::fd::FromRawFd;
-        let owned = std::io::stdin().as_fd().try_clone_to_owned().unwrap();
-        let raw = owned.into_raw_fd(); // transfer ownership
-        // SAFETY: `raw` is a fresh, owned fd; PipeReader will close it.
-        unsafe { std::io::PipeReader::from_raw_fd(raw) }
+      use std::os::fd::AsFd;
+      use std::os::fd::FromRawFd;
+      use std::os::fd::IntoRawFd;
+      let owned = std::io::stdin().as_fd().try_clone_to_owned().unwrap();
+      let raw = owned.into_raw_fd();
+      // SAFETY: `raw` is a fresh, owned fd; PipeReader will close it.
+      unsafe { std::io::PipeReader::from_raw_fd(raw) }
     }
 
     #[cfg(windows)]
     pub fn dup_stdin_as_pipe_reader() -> io::Result<PipeReader> {
-        use std::os::windows::io::AsHandle;
-        use std::os::windows::io::IntoRawHandle;
-        use std::os::windows::io::FromRawHandle;
-        let owned = io::stdin().as_handle().try_clone_to_owned().unwrap();
-        let raw = owned.into_raw_handle(); // transfer ownership
-        // SAFETY: `raw` is a fresh, owned HANDLE; PipeReader will close it.
-        unsafe { std::io::PipeReader::from_raw_handle(raw) }
+      use std::os::windows::io::AsHandle;
+      use std::os::windows::io::FromRawHandle;
+      use std::os::windows::io::IntoRawHandle;
+      let owned = io::stdin().as_handle().try_clone_to_owned().unwrap();
+      let raw = owned.into_raw_handle();
+      // SAFETY: `raw` is a fresh, owned HANDLE; PipeReader will close it.
+      unsafe { std::io::PipeReader::from_raw_handle(raw) }
     }
 
     ShellPipeReader::OsPipe(dup_stdin_as_pipe_reader())