7 files changed, 310 insertions, 171 deletions

diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs
index 67d1f41bc..2d9ae904b 100644
--- a/xtask/src/ast_src.rs
+++ b/xtask/src/ast_src.rs
@@ -120,6 +120,8 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
         "FOR_TYPE",
         "IMPL_TRAIT_TYPE",
         "DYN_TRAIT_TYPE",
+        "OR_PAT",
+        "PAREN_PAT",
         "REF_PAT",
         "BOX_PAT",
         "BIND_PAT",
@@ -412,26 +414,28 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
         struct MatchExpr { Expr, MatchArmList }
         struct MatchArmList: AttrsOwner { arms: [MatchArm] }
         struct MatchArm: AttrsOwner {
-            pats: [Pat],
+            pat: Pat,
             guard: MatchGuard,
             Expr,
-         }
+        }
         struct MatchGuard { Expr }
 
         struct RecordLit { Path, RecordFieldList }
         struct RecordFieldList {
             fields: [RecordField],
             spread: Expr,
-         }
+        }
         struct RecordField { NameRef, Expr }
 
+        struct OrPat { pats: [Pat] }
+        struct ParenPat { Pat }
         struct RefPat { Pat }
         struct BoxPat { Pat }
         struct BindPat: NameOwner { Pat }
         struct PlaceholderPat { }
         struct DotDotPat { }
-        struct PathPat {  Path }
-        struct SlicePat {}
+        struct PathPat { Path }
+        struct SlicePat { args: [Pat] }
         struct RangePat {}
         struct LiteralPat { Literal }
 
@@ -601,6 +605,8 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
         }
 
         enum Pat {
+            OrPat,
+            ParenPat,
             RefPat,
             BoxPat,
             BindPat,
diff --git a/xtask/src/cmd.rs b/xtask/src/cmd.rs
deleted file mode 100644
index 2027f4893..000000000
--- a/xtask/src/cmd.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::process::{Command, Output, Stdio};
-
-use anyhow::{Context, Result};
-
-use crate::project_root;
-
-pub struct Cmd<'a> {
-    pub unix: &'a str,
-    pub windows: &'a str,
-    pub work_dir: &'a str,
-}
-
-impl Cmd<'_> {
-    pub fn run(self) -> Result<()> {
-        if cfg!(windows) {
-            run(self.windows, self.work_dir)
-        } else {
-            run(self.unix, self.work_dir)
-        }
-    }
-    pub fn run_with_output(self) -> Result<Output> {
-        if cfg!(windows) {
-            run_with_output(self.windows, self.work_dir)
-        } else {
-            run_with_output(self.unix, self.work_dir)
-        }
-    }
-}
-
-pub fn run(cmdline: &str, dir: &str) -> Result<()> {
-    do_run(cmdline, dir, &mut |c| {
-        c.stdout(Stdio::inherit());
-    })
-    .map(|_| ())
-}
-
-pub fn run_with_output(cmdline: &str, dir: &str) -> Result<Output> {
-    do_run(cmdline, dir, &mut |_| {})
-}
-
-fn do_run(cmdline: &str, dir: &str, f: &mut dyn FnMut(&mut Command)) -> Result<Output> {
-    eprintln!("\nwill run: {}", cmdline);
-    let proj_dir = project_root().join(dir);
-    let mut args = cmdline.split_whitespace();
-    let exec = args.next().unwrap();
-    let mut cmd = Command::new(exec);
-    f(cmd.args(args).current_dir(proj_dir).stderr(Stdio::inherit()));
-    let output = cmd.output().with_context(|| format!("running `{}`", cmdline))?;
-    if !output.status.success() {
-        anyhow::bail!("`{}` exited with {}", cmdline, output.status);
-    }
-    Ok(output)
-}
diff --git a/xtask/src/install.rs b/xtask/src/install.rs
index 8c65b51e3..00bbabce4 100644
--- a/xtask/src/install.rs
+++ b/xtask/src/install.rs
@@ -2,9 +2,9 @@
 
 use std::{env, path::PathBuf, str};
 
-use anyhow::{Context, Result};
+use anyhow::{bail, format_err, Context, Result};
 
-use crate::cmd::{run, run_with_output, Cmd};
+use crate::not_bash::{ls, pushd, rm, run};
 
 // Latest stable, feel free to send a PR if this lags behind.
 const REQUIRED_RUST_VERSION: u32 = 41;
@@ -24,6 +24,7 @@ pub struct ServerOpt {
 
 impl InstallCmd {
     pub fn run(self) -> Result<()> {
+        let both = self.server.is_some() && self.client.is_some();
         if cfg!(target_os = "macos") {
             fix_path_for_mac().context("Fix path for mac")?
         }
@@ -33,6 +34,16 @@ impl InstallCmd {
         if let Some(client) = self.client {
             install_client(client).context("install client")?;
         }
+        if both {
+            eprintln!(
+                "
+    Installation complete.
+
+    Add `\"rust-analyzer.raLspServerPath\": \"ra_lsp_server\",` to VS Code settings,
+    otherwise it will use the latest release from GitHub.
+"
+            )
+        }
         Ok(())
     }
 }
@@ -44,7 +55,7 @@ fn fix_path_for_mac() -> Result<()> {
         const ROOT_DIR: &str = "";
         let home_dir = match env::var("HOME") {
             Ok(home) => home,
-            Err(e) => anyhow::bail!("Failed getting HOME from environment with error: {}.", e),
+            Err(e) => bail!("Failed getting HOME from environment with error: {}.", e),
         };
 
         [ROOT_DIR, &home_dir]
@@ -58,7 +69,7 @@ fn fix_path_for_mac() -> Result<()> {
     if !vscode_path.is_empty() {
         let vars = match env::var_os("PATH") {
             Some(path) => path,
-            None => anyhow::bail!("Could not get PATH variable from env."),
+            None => bail!("Could not get PATH variable from env."),
         };
 
         let mut paths = env::split_paths(&vars).collect::<Vec<_>>();
@@ -71,91 +82,63 @@ fn fix_path_for_mac() -> Result<()> {
 }
 
 fn install_client(ClientOpt::VsCode: ClientOpt) -> Result<()> {
-    let npm_version = Cmd {
-        unix: r"npm --version",
-        windows: r"cmd.exe /c npm --version",
-        work_dir: "./editors/code",
-    }
-    .run();
+    let _dir = pushd("./editors/code");
 
-    if npm_version.is_err() {
-        eprintln!("\nERROR: `npm --version` failed, `npm` is required to build the VS Code plugin")
-    }
+    let find_code = |f: fn(&str) -> bool| -> Result<&'static str> {
+        ["code", "code-insiders", "codium", "code-oss"]
+            .iter()
+            .copied()
+            .find(|bin| f(bin))
+            .ok_or_else(|| {
+                format_err!("Can't execute `code --version`. Perhaps it is not in $PATH?")
+            })
+    };
 
-    Cmd { unix: r"npm install", windows: r"cmd.exe /c npm install", work_dir: "./editors/code" }
-        .run()?;
-    Cmd {
-        unix: r"npm run package --scripts-prepend-node-path",
-        windows: r"cmd.exe /c npm run package",
-        work_dir: "./editors/code",
-    }
-    .run()?;
+    let installed_extensions;
+    if cfg!(unix) {
+        run!("npm --version").context("`npm` is required to build the VS Code plugin")?;
+        run!("npm install")?;
 
-    let code_binary = ["code", "code-insiders", "codium", "code-oss"].iter().find(|bin| {
-        Cmd {
-            unix: &format!("{} --version", bin),
-            windows: &format!("cmd.exe /c {}.cmd --version", bin),
-            work_dir: "./editors/code",
-        }
-        .run()
-        .is_ok()
-    });
+        let vsix_pkg = {
+            rm("*.vsix")?;
+            run!("npm run package --scripts-prepend-node-path")?;
+            ls("*.vsix")?.pop().unwrap()
+        };
 
-    let code_binary = match code_binary {
-        Some(it) => it,
-        None => anyhow::bail!("Can't execute `code --version`. Perhaps it is not in $PATH?"),
-    };
+        let code = find_code(|bin| run!("{} --version", bin).is_ok())?;
+        run!("{} --install-extension {} --force", code, vsix_pkg.display())?;
+        installed_extensions = run!("{} --list-extensions", code; echo = false)?;
+    } else {
+        run!("cmd.exe /c npm --version")
+            .context("`npm` is required to build the VS Code plugin")?;
+        run!("cmd.exe /c npm install")?;
+
+        let vsix_pkg = {
+            rm("*.vsix")?;
+            run!("cmd.exe /c npm run package")?;
+            ls("*.vsix")?.pop().unwrap()
+        };
 
-    Cmd {
-        unix: &format!(r"{} --install-extension ./rust-analyzer-0.1.0.vsix --force", code_binary),
-        windows: &format!(
-            r"cmd.exe /c {}.cmd --install-extension ./rust-analyzer-0.1.0.vsix --force",
-            code_binary
-        ),
-        work_dir: "./editors/code",
+        let code = find_code(|bin| run!("cmd.exe /c {}.cmd --version", bin).is_ok())?;
+        run!(r"cmd.exe /c {}.cmd --install-extension {} --force", code, vsix_pkg.display())?;
+        installed_extensions = run!("cmd.exe /c {}.cmd --list-extensions", code; echo = false)?;
     }
-    .run()?;
-
-    let installed_extensions = {
-        let output = Cmd {
-            unix: &format!(r"{} --list-extensions", code_binary),
-            windows: &format!(r"cmd.exe /c {}.cmd --list-extensions", code_binary),
-            work_dir: ".",
-        }
-        .run_with_output()?;
-        String::from_utf8(output.stdout)?
-    };
 
     if !installed_extensions.contains("rust-analyzer") {
-        anyhow::bail!(
+        bail!(
             "Could not install the Visual Studio Code extension. \
-             Please make sure you have at least NodeJS 10.x together with the latest version of VS Code installed and try again."
+             Please make sure you have at least NodeJS 12.x together with the latest version of VS Code installed and try again."
         );
     }
 
-    if installed_extensions.contains("ra-lsp") {
-        Cmd {
-            unix: &format!(r"{} --uninstall-extension matklad.ra-lsp", code_binary),
-            windows: &format!(
-                r"cmd.exe /c {}.cmd --uninstall-extension matklad.ra-lsp",
-                code_binary
-            ),
-            work_dir: "./editors/code",
-        }
-        .run()?;
-    }
-
     Ok(())
 }
 
 fn install_server(opts: ServerOpt) -> Result<()> {
     let mut old_rust = false;
-    if let Ok(output) = run_with_output("cargo --version", ".") {
-        if let Ok(stdout) = String::from_utf8(output.stdout) {
-            println!("{}", stdout);
-            if !check_version(&stdout, REQUIRED_RUST_VERSION) {
-                old_rust = true;
-            }
+    if let Ok(stdout) = run!("cargo --version") {
+        if !check_version(&stdout, REQUIRED_RUST_VERSION) {
+            old_rust = true;
         }
     }
 
@@ -166,20 +149,17 @@ fn install_server(opts: ServerOpt) -> Result<()> {
         )
     }
 
-    let res = if opts.jemalloc {
-        run("cargo install --path crates/ra_lsp_server --locked --force --features jemalloc", ".")
-    } else {
-        run("cargo install --path crates/ra_lsp_server --locked --force", ".")
-    };
+    let jemalloc = if opts.jemalloc { "--features jemalloc" } else { "" };
+    let res = run!("cargo install --path crates/ra_lsp_server --locked --force {}", jemalloc);
 
     if res.is_err() && old_rust {
         eprintln!(
             "\nWARNING: at least rust 1.{}.0 is required to compile rust-analyzer\n",
             REQUIRED_RUST_VERSION,
-        )
+        );
     }
 
-    res
+    res.map(drop)
 }
 
 fn check_version(version_output: &str, min_minor_version: u32) -> bool {
diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs
index 8fdf43e4a..2bcd76d60 100644
--- a/xtask/src/lib.rs
+++ b/xtask/src/lib.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-mod cmd;
+pub mod not_bash;
 pub mod install;
 pub mod pre_commit;
 
@@ -9,13 +9,16 @@ mod ast_src;
 
 use anyhow::Context;
 use std::{
-    env, fs,
+    env,
     io::Write,
     path::{Path, PathBuf},
     process::{Command, Stdio},
 };
 
-use crate::{cmd::run, codegen::Mode};
+use crate::{
+    codegen::Mode,
+    not_bash::{fs2, pushd, rm_rf, run},
+};
 
 pub use anyhow::Result;
 
@@ -35,9 +38,9 @@ pub fn run_rustfmt(mode: Mode) -> Result<()> {
     ensure_rustfmt()?;
 
     if mode == Mode::Verify {
-        run(&format!("rustup run {} -- cargo fmt -- --check", TOOLCHAIN), ".")?;
+        run!("rustup run {} -- cargo fmt -- --check", TOOLCHAIN)?;
     } else {
-        run(&format!("rustup run {} -- cargo fmt", TOOLCHAIN), ".")?;
+        run!("rustup run {} -- cargo fmt", TOOLCHAIN)?;
     }
     Ok(())
 }
@@ -67,8 +70,9 @@ fn ensure_rustfmt() -> Result<()> {
         Ok(status) if status.success() => return Ok(()),
         _ => (),
     };
-    run(&format!("rustup toolchain install {}", TOOLCHAIN), ".")?;
-    run(&format!("rustup component add rustfmt --toolchain {}", TOOLCHAIN), ".")
+    run!("rustup toolchain install {}", TOOLCHAIN)?;
+    run!("rustup component add rustfmt --toolchain {}", TOOLCHAIN)?;
+    Ok(())
 }
 
 pub fn run_clippy() -> Result<()> {
@@ -89,34 +93,28 @@ pub fn run_clippy() -> Result<()> {
         "clippy::nonminimal_bool",
         "clippy::redundant_pattern_matching",
     ];
-    run(
-        &format!(
-            "rustup run {} -- cargo clippy --all-features --all-targets -- -A {}",
-            TOOLCHAIN,
-            allowed_lints.join(" -A ")
-        ),
-        ".",
+    run!(
+        "rustup run {} -- cargo clippy --all-features --all-targets -- -A {}",
+        TOOLCHAIN,
+        allowed_lints.join(" -A ")
     )?;
     Ok(())
 }
 
 fn install_clippy() -> Result<()> {
-    run(&format!("rustup toolchain install {}", TOOLCHAIN), ".")?;
-    run(&format!("rustup component add clippy --toolchain {}", TOOLCHAIN), ".")
+    run!("rustup toolchain install {}", TOOLCHAIN)?;
+    run!("rustup component add clippy --toolchain {}", TOOLCHAIN)?;
+    Ok(())
 }
 
 pub fn run_fuzzer() -> Result<()> {
-    match Command::new("cargo")
-        .args(&["fuzz", "--help"])
-        .stderr(Stdio::null())
-        .stdout(Stdio::null())
-        .status()
-    {
-        Ok(status) if status.success() => (),
-        _ => run("cargo install cargo-fuzz", ".")?,
+    let _d = pushd("./crates/ra_syntax");
+    if run!("cargo fuzz --help").is_err() {
+        run!("cargo install cargo-fuzz")?;
     };
 
-    run("rustup run nightly -- cargo fuzz run parser", "./crates/ra_syntax")
+    run!("rustup run nightly -- cargo fuzz run parser")?;
+    Ok(())
 }
 
 /// Cleans the `./target` dir after the build such that only
@@ -138,7 +136,7 @@ pub fn run_pre_cache() -> Result<()> {
         }
     }
 
-    fs::remove_file("./target/.rustc_info.json")?;
+    fs2::remove_file("./target/.rustc_info.json")?;
     let to_delete = ["ra_", "heavy_test"];
     for &dir in ["./target/debug/deps", "target/debug/.fingerprint"].iter() {
         for entry in Path::new(dir).read_dir()? {
@@ -152,7 +150,45 @@ pub fn run_pre_cache() -> Result<()> {
     Ok(())
 }
 
-fn rm_rf(path: &Path) -> Result<()> {
-    if path.is_file() { fs::remove_file(path) } else { fs::remove_dir_all(path) }
-        .with_context(|| format!("failed to remove {:?}", path))
+pub fn run_release(dry_run: bool) -> Result<()> {
+    if !dry_run {
+        run!("git switch release")?;
+        run!("git fetch upstream")?;
+        run!("git reset --hard upstream/master")?;
+        run!("git push")?;
+    }
+
+    let website_root = project_root().join("../rust-analyzer.github.io");
+    let changelog_dir = website_root.join("./thisweek/_posts");
+
+    let today = run!("date --iso")?;
+    let commit = run!("git rev-parse HEAD")?;
+    let changelog_n = fs2::read_dir(changelog_dir.as_path())?.count();
+
+    let contents = format!(
+        "\
+= Changelog #{}
+:sectanchors:
+:page-layout: post
+
+Commit: commit:{}[] +
+Release: release:{}[]
+
+== New Features
+
+* pr:[] .
+
+== Fixes
+
+== Internal Improvements
+",
+        changelog_n, commit, today
+    );
+
+    let path = changelog_dir.join(format!("{}-changelog-{}.adoc", today, changelog_n));
+    fs2::write(&path, &contents)?;
+
+    fs2::copy(project_root().join("./docs/user/readme.adoc"), website_root.join("manual.adoc"))?;
+
+    Ok(())
 }
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index c347de9ab..a7dffe2cc 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -14,7 +14,7 @@ use pico_args::Arguments;
 use xtask::{
     codegen::{self, Mode},
     install::{ClientOpt, InstallCmd, ServerOpt},
-    pre_commit, run_clippy, run_fuzzer, run_pre_cache, run_rustfmt, Result,
+    pre_commit, run_clippy, run_fuzzer, run_pre_cache, run_release, run_rustfmt, Result,
 };
 
 fn main() -> Result<()> {
@@ -92,6 +92,11 @@ FLAGS:
             args.finish()?;
             run_pre_cache()
         }
+        "release" => {
+            let dry_run = args.contains("--dry-run");
+            args.finish()?;
+            run_release(dry_run)
+        }
         _ => {
             eprintln!(
                 "\
diff --git a/xtask/src/not_bash.rs b/xtask/src/not_bash.rs
new file mode 100644
index 000000000..3e30e7279
--- /dev/null
+++ b/xtask/src/not_bash.rs
@@ -0,0 +1,165 @@
+//! A bad shell -- small cross platform module for writing glue code
+use std::{
+    cell::RefCell,
+    env,
+    ffi::OsStr,
+    fs,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
+
+use anyhow::{bail, Context, Result};
+
+pub mod fs2 {
+    use std::{fs, path::Path};
+
+    use anyhow::{Context, Result};
+
+    pub fn read_dir<P: AsRef<Path>>(path: P) -> Result<fs::ReadDir> {
+        let path = path.as_ref();
+        fs::read_dir(path).with_context(|| format!("Failed to read {}", path.display()))
+    }
+
+    pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> Result<()> {
+        let path = path.as_ref();
+        fs::write(path, contents).with_context(|| format!("Failed to write {}", path.display()))
+    }
+
+    pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<u64> {
+        let from = from.as_ref();
+        let to = to.as_ref();
+        fs::copy(from, to)
+            .with_context(|| format!("Failed to copy {} to {}", from.display(), to.display()))
+    }
+
+    pub fn remove_file<P: AsRef<Path>>(path: P) -> Result<()> {
+        let path = path.as_ref();
+        fs::remove_file(path).with_context(|| format!("Failed to remove file {}", path.display()))
+    }
+
+    pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> Result<()> {
+        let path = path.as_ref();
+        fs::remove_dir_all(path).with_context(|| format!("Failed to remove dir {}", path.display()))
+    }
+}
+
+macro_rules! _run {
+    ($($expr:expr),*) => {
+        run!($($expr),*; echo = true)
+    };
+    ($($expr:expr),* ; echo = $echo:expr) => {
+        $crate::not_bash::run_process(format!($($expr),*), $echo)
+    };
+}
+pub(crate) use _run as run;
+
+pub struct Pushd {
+    _p: (),
+}
+
+pub fn pushd(path: impl Into<PathBuf>) -> Pushd {
+    Env::with(|env| env.pushd(path.into()));
+    Pushd { _p: () }
+}
+
+impl Drop for Pushd {
+    fn drop(&mut self) {
+        Env::with(|env| env.popd())
+    }
+}
+
+pub fn rm(glob: &str) -> Result<()> {
+    let cwd = Env::with(|env| env.cwd());
+    ls(glob)?.into_iter().try_for_each(|it| fs::remove_file(cwd.join(it)))?;
+    Ok(())
+}
+
+pub fn rm_rf(path: impl AsRef<Path>) -> Result<()> {
+    let path = path.as_ref();
+    if path.is_file() {
+        fs2::remove_file(path)
+    } else {
+        fs2::remove_dir_all(path)
+    }
+}
+
+pub fn ls(glob: &str) -> Result<Vec<PathBuf>> {
+    let cwd = Env::with(|env| env.cwd());
+    let mut res = Vec::new();
+    for entry in fs::read_dir(&cwd)? {
+        let entry = entry?;
+        if matches(&entry.file_name(), glob) {
+            let path = entry.path();
+            let path = path.strip_prefix(&cwd).unwrap();
+            res.push(path.to_path_buf())
+        }
+    }
+    return Ok(res);
+
+    fn matches(file_name: &OsStr, glob: &str) -> bool {
+        assert!(glob.starts_with('*'));
+        file_name.to_string_lossy().ends_with(&glob[1..])
+    }
+}
+
+#[doc(hidden)]
+pub fn run_process(cmd: String, echo: bool) -> Result<String> {
+    run_process_inner(&cmd, echo).with_context(|| format!("process `{}` failed", cmd))
+}
+
+fn run_process_inner(cmd: &str, echo: bool) -> Result<String> {
+    let cwd = Env::with(|env| env.cwd());
+    let mut args = shelx(cmd);
+    let binary = args.remove(0);
+
+    if echo {
+        println!("> {}", cmd)
+    }
+
+    let output = Command::new(binary)
+        .args(args)
+        .current_dir(cwd)
+        .stdin(Stdio::null())
+        .stderr(Stdio::inherit())
+        .output()?;
+    let stdout = String::from_utf8(output.stdout)?;
+
+    if echo {
+        print!("{}", stdout)
+    }
+
+    if !output.status.success() {
+        bail!("{}", output.status)
+    }
+
+    Ok(stdout.trim().to_string())
+}
+
+// FIXME: some real shell lexing here
+fn shelx(cmd: &str) -> Vec<String> {
+    cmd.split_whitespace().map(|it| it.to_string()).collect()
+}
+
+#[derive(Default)]
+struct Env {
+    pushd_stack: Vec<PathBuf>,
+}
+
+impl Env {
+    fn with<F: FnOnce(&mut Env) -> T, T>(f: F) -> T {
+        thread_local! {
+            static ENV: RefCell<Env> = Default::default();
+        }
+        ENV.with(|it| f(&mut *it.borrow_mut()))
+    }
+
+    fn pushd(&mut self, dir: PathBuf) {
+        self.pushd_stack.push(dir)
+    }
+    fn popd(&mut self) {
+        self.pushd_stack.pop().unwrap();
+    }
+    fn cwd(&self) -> PathBuf {
+        self.pushd_stack.last().cloned().unwrap_or_else(|| env::current_dir().unwrap())
+    }
+}
diff --git a/xtask/src/pre_commit.rs b/xtask/src/pre_commit.rs
index 88e868ca6..056f34acf 100644
--- a/xtask/src/pre_commit.rs
+++ b/xtask/src/pre_commit.rs
@@ -4,18 +4,18 @@ use std::{fs, path::PathBuf};
 
 use anyhow::{bail, Result};
 
-use crate::{cmd::run_with_output, project_root, run, run_rustfmt, Mode};
+use crate::{not_bash::run, project_root, run_rustfmt, Mode};
 
 // FIXME: if there are changed `.ts` files, also reformat TypeScript (by
 // shelling out to `npm fmt`).
 pub fn run_hook() -> Result<()> {
     run_rustfmt(Mode::Overwrite)?;
 
-    let diff = run_with_output("git diff --diff-filter=MAR --name-only --cached", ".")?;
+    let diff = run!("git diff --diff-filter=MAR --name-only --cached")?;
 
     let root = project_root();
-    for line in String::from_utf8(diff.stdout)?.lines() {
-        run(&format!("git update-index --add {}", root.join(line).to_string_lossy()), ".")?;
+    for line in diff.lines() {
+        run!("git update-index --add {}", root.join(line).display())?;
     }
 
     Ok(())