A couple minor improvements for tidy error handling.

src/tools/tidy/src/bins.rs

@@ -62,8 +62,7 @@ pub fn check(path: &Path, bad: &mut bool) {
                 });
             let path_bytes = rel_path.as_os_str().as_bytes();
             if output.status.success() && output.stdout.starts_with(path_bytes) {
-                println!("binary checked into source: {}", file.display());
-                *bad = true;
+                tidy_error!(bad, "binary checked into source: {}", file.display());
             }
         }
     })

src/tools/tidy/src/cargo.rs

@@ -100,9 +100,8 @@ fn verify(tomlfile: &Path, libfile: &Path, bad: &mut bool) {
         }
 
         if !librs.contains(&format!("extern crate {}", krate)) {
-            println!("{} doesn't have `extern crate {}`, but Cargo.toml \
-                      depends on it", libfile.display(), krate);
-            *bad = true;
+            tidy_error!(bad, "{} doesn't have `extern crate {}`, but Cargo.toml \
+                              depends on it", libfile.display(), krate);
         }
     }
 }

src/tools/tidy/src/errors.rs

@@ -79,11 +79,10 @@ pub fn check(path: &Path, bad: &mut bool) {
             continue
         }
 
-        println!("duplicate error code: {}", code);
+        tidy_error!(bad, "duplicate error code: {}", code);
         for &(ref file, line_num, ref line) in entries.iter() {
-            println!("{}:{}: {}", file.display(), line_num, line);
+            tidy_error!(bad, "{}:{}: {}", file.display(), line_num, line);
         }
-        *bad = true;
     }
 
     if !*bad {

src/tools/tidy/src/features.rs

@@ -77,8 +77,7 @@ pub fn check(path: &Path, bad: &mut bool) {
 
         for (i, line) in contents.lines().enumerate() {
             let mut err = |msg: &str| {
-                println!("{}:{}: {}", file.display(), i + 1, msg);
-                *bad = true;
+                tidy_error!(bad, "{}:{}: {}", file.display(), i + 1, msg);
             };
 
             let gate_test_str = "gate-test-";
@@ -126,8 +125,7 @@ pub fn check(path: &Path, bad: &mut bool) {
     }
 
     if gate_untested.len() > 0 {
-        println!("Found {} features without a gate test.", gate_untested.len());
-        *bad = true;
+        tidy_error!(bad, "Found {} features without a gate test.", gate_untested.len());
     }
 
     if *bad {
@@ -221,8 +219,7 @@ pub fn collect_lib_features(base_src_path: &Path,
 
         for (i, line) in contents.lines().enumerate() {
             let mut err = |msg: &str| {
-                println!("{}:{}: {}", file.display(), i + 1, msg);
-                *bad = true;
+                tidy_error!(bad, "{}:{}: {}", file.display(), i + 1, msg);
             };
             let level = if line.contains("[unstable(") {
                 Status::Unstable

src/tools/tidy/src/main.rs

@@ -16,9 +16,11 @@
 
 extern crate regex;
 
+use std::env;
 use std::fs;
+use std::io::{self, Write};
 use std::path::{PathBuf, Path};
-use std::env;
+use std::process;
 
 macro_rules! t {
     ($e:expr, $p:expr) => (match $e {
@@ -32,6 +34,15 @@ macro_rules! t {
     })
 }
 
+macro_rules! tidy_error {
+    ($bad:expr, $fmt:expr, $($arg:tt)*) => ({
+        use std::io::Write;
+        *$bad = true;
+        write!(::std::io::stderr(), "tidy error: ").expect("could not write to stderr");
+        writeln!(::std::io::stderr(), $fmt, $($arg)*).expect("could not write to stderr");
+    });
+}
+
 mod bins;
 mod style;
 mod errors;
@@ -60,7 +71,8 @@ fn main() {
     }
 
     if bad {
-        panic!("some tidy checks failed");
+        writeln!(io::stderr(), "some tidy checks failed").expect("could not write to stderr");
+        process::exit(1);
     }
 }
 

src/tools/tidy/src/pal.rs

@@ -126,8 +126,7 @@ fn check_cfgs(contents: &mut String, file: &Path,
             Ok(_) => unreachable!(),
             Err(i) => i + 1
         };
-        println!("{}:{}: platform-specific cfg: {}", file.display(), line, cfg);
-        *bad = true;
+        tidy_error!(bad, "{}:{}: platform-specific cfg: {}", file.display(), line, cfg);
     };
 
     for (idx, cfg) in cfgs.into_iter() {

src/tools/tidy/src/style.rs

@@ -112,8 +112,7 @@ pub fn check(path: &Path, bad: &mut bool) {
         let skip_length = contents.contains("ignore-tidy-linelength");
         for (i, line) in contents.split("\n").enumerate() {
             let mut err = |msg: &str| {
-                println!("{}:{}: {}", file.display(), i + 1, msg);
-                *bad = true;
+                tidy_error!(bad, "{}:{}: {}", file.display(), i + 1, msg);
             };
             if !skip_length && line.chars().count() > COLS
                 && !long_line_is_ok(line) {
@@ -138,8 +137,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             }
         }
         if !licenseck(file, &contents) {
-            println!("{}: incorrect license", file.display());
-            *bad = true;
+            tidy_error!(bad, "{}: incorrect license", file.display());
         }
     })
 }

src/tools/tidy/src/unstable_book.rs

@@ -10,7 +10,7 @@
 
 use std::collections::HashSet;
 use std::fs;
-use std::io::{self, BufRead, Write};
+use std::io::{self, BufRead};
 use std::path;
 use features::{collect_lang_features, collect_lib_features, Status};
 
@@ -110,29 +110,26 @@ pub fn check(path: &path::Path, bad: &mut bool) {
 
     // Check for Unstable Book section names with no corresponding SUMMARY.md link
     for feature_name in &unstable_book_section_file_names - &unstable_book_links {
-        *bad = true;
-        writeln!(io::stderr(),
-                 "The Unstable Book section '{}' needs to have a link in SUMMARY.md",
-                 feature_name)
-                .expect("could not write to stderr")
+        tidy_error!(
+            bad,
+            "The Unstable Book section '{}' needs to have a link in SUMMARY.md",
+            feature_name);
     }
 
     // Check for unstable features that don't have Unstable Book sections
     for feature_name in &unstable_feature_names - &unstable_book_section_file_names {
-        *bad = true;
-        writeln!(io::stderr(),
-                 "Unstable feature '{}' needs to have a section in The Unstable Book",
-                 feature_name)
-                .expect("could not write to stderr")
+        tidy_error!(
+            bad,
+            "Unstable feature '{}' needs to have a section in The Unstable Book",
+            feature_name);
     }
 
     // Check for Unstable Book sections that don't have a corresponding unstable feature
     for feature_name in &unstable_book_section_file_names - &unstable_feature_names {
-        *bad = true;
-        writeln!(io::stderr(),
-                 "The Unstable Book has a section '{}' which doesn't correspond \
-                  to an unstable feature",
-                 feature_name)
-                .expect("could not write to stderr")
+        tidy_error!(
+            bad,
+            "The Unstable Book has a section '{}' which doesn't correspond \
+            to an unstable feature",
+            feature_name)
     }
 }