Use eprintln! and println! instead of writeln! with stderr (#86)

Author: toku-sa-n

src/extensions.rs

@@ -1,5 +1,3 @@
-use std::io;
-use std::io::Write;
 use std::process::{Command, ExitStatus};
 
 use errors::*;
@@ -29,7 +27,7 @@ impl CommandExt for Command {
     /// Runs the command to completion
     fn run_and_get_status(&mut self, verbose: bool) -> Result<ExitStatus> {
         if verbose {
-            writeln!(io::stderr(), "+ {:?}", self).ok();
+            eprintln!("+ {:?}", self);
         }
 
         self.status()
@@ -39,7 +37,7 @@ impl CommandExt for Command {
     /// Runs the command to completion and returns its stdout
     fn run_and_get_stdout(&mut self, verbose: bool) -> Result<String> {
         if verbose {
-            writeln!(io::stderr(), "+ {:?}", self).ok();
+            eprintln!("+ {:?}", self);
         }
 
         let out = self

src/flock.rs

@@ -2,7 +2,6 @@
 //! other Cargo stuff
 
 use std::fs::{File, OpenOptions};
-use std::io::Write;
 use std::path::{Display, Path, PathBuf};
 use std::{fs, io};
 
@@ -181,13 +180,11 @@ fn acquire(
     }
 
     if !quiet {
-        writeln!(
-            io::stderr(),
+        eprintln!(
             "{:>12} waiting for file lock on {}",
             "Blocking",
             msg
         )
-        .ok();
     }
 
     block()

src/lib.rs

@@ -16,10 +16,9 @@ extern crate toml;
 extern crate walkdir;
 
 use std::hash::{Hash, Hasher};
-use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::ExitStatus;
-use std::{env, io, process};
+use std::{env, process};
 
 use rustc_version::Channel;
 
@@ -96,21 +95,18 @@ pub fn main_common(command_name: &str) {
 
     match run(command_name) {
         Err(e) => {
-            let stderr = io::stderr();
-            let mut stderr = stderr.lock();
-
-            writeln!(stderr, "error: {}", e).ok();
+            eprintln!("error: {}", e);
 
             for e in e.iter().skip(1) {
-                writeln!(stderr, "caused by: {}", e).ok();
+                eprintln!("caused by: {}", e);
             }
 
             if show_backtrace() {
                 if let Some(backtrace) = e.backtrace() {
-                    writeln!(stderr, "{:?}", backtrace).ok();
+                    eprintln!("{:?}", backtrace);
                 }
             } else {
-                writeln!(stderr, "note: run with `RUST_BACKTRACE=1` for a backtrace").ok();
+                eprintln!("note: run with `RUST_BACKTRACE=1` for a backtrace");
             }
 
             process::exit(1)
@@ -135,12 +131,10 @@ fn run(command_name: &str) -> Result<Option<ExitStatus>> {
             Ok(None)
         }
         Command::Version => {
-            writeln!(
-                io::stdout(),
+            println!(
                 concat!("cargo-xbuild ", env!("CARGO_PKG_VERSION"), "{}"),
                 include_str!(concat!(env!("OUT_DIR"), "/commit-info.txt"))
-            )
-            .unwrap();
+            );
             Ok(None)
         }
     }

src/sysroot.rs

@@ -2,8 +2,6 @@ use std::collections::hash_map::DefaultHasher;
 use std::env;
 use std::fs;
 use std::hash::{Hash, Hasher};
-use std::io;
-use std::io::Write;
 use std::path::Path;
 use std::process::Command;
 
@@ -64,7 +62,10 @@ fn build_crate(
     dst: &Path,
     verbose: bool,
 ) -> Result<()> {
-    let td = Builder::new().prefix("cargo-xbuild").tempdir().chain_err(|| "couldn't create a temporary directory")?;
+    let td = Builder::new()
+        .prefix("cargo-xbuild")
+        .tempdir()
+        .chain_err(|| "couldn't create a temporary directory")?;
     let td_path;
     let td = if env::var_os("XBUILD_KEEP_TEMP").is_some() {
         td_path = td.into_path();
@@ -85,10 +86,13 @@ fn build_crate(
     }
 
     util::write(&td.join("Cargo.toml"), &stoml)?;
-    fs::copy(lockfile, &td.join("Cargo.lock")).chain_err(||
-        format!("failed to copy Cargo.lock from `{}` to `{}`",
-            lockfile.display(), &td.join("Cargo.lock").display())
-    )?;
+    fs::copy(lockfile, &td.join("Cargo.lock")).chain_err(|| {
+        format!(
+            "failed to copy Cargo.lock from `{}` to `{}`",
+            lockfile.display(),
+            &td.join("Cargo.lock").display()
+        )
+    })?;
     util::mkdir(&td.join("src"))?;
     util::write(&td.join("src/lib.rs"), "")?;
 
@@ -261,7 +265,6 @@ pub fn update(
     verbose: bool,
 ) -> Result<()> {
     let ctoml = cargo::toml(root)?;
-    let mut stderr = io::stderr();
 
     let hash = hash(cmode, rustflags, &ctoml, meta, config)?;
 
@@ -298,14 +301,7 @@ pub fn update(
         &dst,
     ) {
         Ok(()) => {}
-        Err(e) => {
-            writeln!(
-                stderr,
-                "Unable to copy the directory 'lib' from sysroot: {}",
-                e
-            )
-            .ok();
-        }
+        Err(e) => eprintln!("Unable to copy the directory 'lib' from sysroot: {}", e),
     };
 
     let bin_dst = lock.parent().join("bin");
@@ -320,14 +316,7 @@ pub fn update(
         &bin_dst,
     ) {
         Ok(()) => {}
-        Err(e) => {
-            writeln!(
-                stderr,
-                "Unable to copy the directory 'bin' from sysroot: {}",
-                e
-            )
-            .ok();
-        }
+        Err(e) => eprintln!("Unable to copy the directory 'bin' from sysroot: {}", e),
     };
 
     util::write(&hfile, hash)?;

src/xargo.rs

@@ -1,9 +1,8 @@
-use std::io::{self, Write};
+use std::env;
 use std::mem;
 use std::path::Path;
 use std::path::{Display, PathBuf};
 use std::process::{Command, ExitStatus};
-use std::env;
 
 use rustc_version::VersionMeta;
 
@@ -31,8 +30,8 @@ pub fn run(
 
     let flags = rustflags.for_xargo(home)?;
     if verbose {
-        writeln!(io::stderr(), "+ RUSTFLAGS={:?}", flags).ok();
-        writeln!(io::stderr(), "+ RUSTDOCFLAGS={:?}", flags).ok();
+        eprintln!("+ RUSTFLAGS={:?}", flags);
+        eprintln!("+ RUSTDOCFLAGS={:?}", flags);
     }
     cmd.env("RUSTFLAGS", &flags);
     cmd.env("RUSTDOCFLAGS", &flags);
@@ -70,7 +69,13 @@ impl Home {
         let fs = self.path(triple);
 
         fs.open_rw(".sentinel", &format!("{}'s sysroot", triple))
-            .chain_err(|| format!("couldn't lock {}'s sysroot in {} as read-write", triple, fs.display()))
+            .chain_err(|| {
+                format!(
+                    "couldn't lock {}'s sysroot in {} as read-write",
+                    triple,
+                    fs.display()
+                )
+            })
     }
 }