address review comments

Author: durka

src/librustc/session/config.rs

@@ -1036,8 +1036,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
           "run all passes except translation; no output"),
     treat_err_as_bug: bool = (false, parse_bool, [TRACKED],
           "treat all errors that occur as bugs"),
-    macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
-          "show macro backtraces even for foreign macros"),
+    external_macro_backtrace: bool = (false, parse_bool, [UNTRACKED],
+          "show macro backtraces even for non-local macros"),
     continue_parse_after_error: bool = (false, parse_bool, [TRACKED],
           "attempt to recover from parse errors (experimental)"),
     incremental: Option<String> = (None, parse_opt_string, [UNTRACKED],
@@ -2102,7 +2102,7 @@ mod tests {
             let registry = errors::registry::Registry::new(&[]);
             let (sessopts, _) = build_session_options_and_crate_config(&matches);
             let sess = build_session(sessopts, None, registry);
-            assert!(!sess.diagnostic().can_emit_warnings);
+            assert!(!sess.diagnostic().flags.can_emit_warnings);
         }
 
         {
@@ -2113,7 +2113,7 @@ mod tests {
             let registry = errors::registry::Registry::new(&[]);
             let (sessopts, _) = build_session_options_and_crate_config(&matches);
             let sess = build_session(sessopts, None, registry);
-            assert!(sess.diagnostic().can_emit_warnings);
+            assert!(sess.diagnostic().flags.can_emit_warnings);
         }
 
         {
@@ -2123,7 +2123,7 @@ mod tests {
             let registry = errors::registry::Registry::new(&[]);
             let (sessopts, _) = build_session_options_and_crate_config(&matches);
             let sess = build_session(sessopts, None, registry);
-            assert!(sess.diagnostic().can_emit_warnings);
+            assert!(sess.diagnostic().flags.can_emit_warnings);
         }
     }
 

src/librustc/session/mod.rs

@@ -727,11 +727,11 @@ pub fn build_session_with_codemap(sopts: config::Options,
         .unwrap_or(false);
     let cap_lints_allow = sopts.lint_cap.map_or(false, |cap| cap == lint::Allow);
 
-    let can_print_warnings = !(warnings_allow || cap_lints_allow);
+    let can_emit_warnings = !(warnings_allow || cap_lints_allow);
 
     let treat_err_as_bug = sopts.debugging_opts.treat_err_as_bug;
 
-    let macro_backtrace = sopts.debugging_opts.macro_backtrace;
+    let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace;
 
     let emitter: Box<Emitter> = match (sopts.error_format, emitter_dest) {
         (config::ErrorOutputType::HumanReadable(color_config), None) => {
@@ -755,10 +755,14 @@ pub fn build_session_with_codemap(sopts: config::Options,
     };
 
     let diagnostic_handler =
-        errors::Handler::with_emitter(can_print_warnings,
-                                      treat_err_as_bug,
-                                      macro_backtrace,
-                                      emitter);
+        errors::Handler::with_emitter_and_flags(
+            emitter,
+            errors::HandlerFlags {
+                can_emit_warnings,
+                treat_err_as_bug,
+                external_macro_backtrace,
+                .. Default::default()
+            });
 
     build_session_(sopts,
                    local_crate_source_file,
@@ -928,7 +932,7 @@ pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! {
             Box::new(EmitterWriter::stderr(color_config, None, true))
         }
     };
-    let handler = errors::Handler::with_emitter(true, false, false, emitter);
+    let handler = errors::Handler::with_emitter(true, false, emitter);
     handler.emit(&MultiSpan::new(), msg, errors::Level::Fatal);
     panic!(errors::FatalError);
 }
@@ -943,7 +947,7 @@ pub fn early_warn(output: config::ErrorOutputType, msg: &str) {
             Box::new(EmitterWriter::stderr(color_config, None, true))
         }
     };
-    let handler = errors::Handler::with_emitter(true, false, false, emitter);
+    let handler = errors::Handler::with_emitter(true, false, emitter);
     handler.emit(&MultiSpan::new(), msg, errors::Level::Warning);
 }
 

src/librustc_driver/lib.rs

@@ -141,8 +141,7 @@ pub fn run<F>(run_compiler: F) -> isize
                         errors::emitter::EmitterWriter::stderr(errors::ColorConfig::Auto,
                                                                None,
                                                                true);
-                    let handler = errors::Handler::with_emitter(true, false, false,
-                                                                Box::new(emitter));
+                    let handler = errors::Handler::with_emitter(true, false, Box::new(emitter));
                     handler.emit(&MultiSpan::new(),
                                  "aborting due to previous error(s)",
                                  errors::Level::Fatal);
@@ -1222,7 +1221,7 @@ pub fn monitor<F: FnOnce() + Send + 'static>(f: F) {
                 Box::new(errors::emitter::EmitterWriter::stderr(errors::ColorConfig::Auto,
                                                                 None,
                                                                 false));
-            let handler = errors::Handler::with_emitter(true, false, false, emitter);
+            let handler = errors::Handler::with_emitter(true, false, emitter);
 
             // a .span_bug or .bug call has already printed what
             // it wants to print.

src/librustc_driver/test.rs

@@ -104,7 +104,7 @@ fn test_env<F>(source_string: &str,
     let mut options = config::basic_options();
     options.debugging_opts.verbose = true;
     options.unstable_features = UnstableFeatures::Allow;
-    let diagnostic_handler = errors::Handler::with_emitter(true, false, false, emitter);
+    let diagnostic_handler = errors::Handler::with_emitter(true, false, emitter);
 
     let cstore = Rc::new(CStore::new(::DefaultTransCrate::metadata_loader()));
     let sess = session::build_session_(options,

src/librustc_errors/emitter.rs

@@ -64,11 +64,11 @@ impl Emitter for EmitterWriter {
             }
         }
 
-        if !db.handler.macro_backtrace {
+        if !db.handler.flags.external_macro_backtrace {
             self.fix_multispans_in_std_macros(&mut primary_span, &mut children);
         }
         self.emit_messages_default(&db.level,
-                                   db.handler.macro_backtrace,
+                                   db.handler.flags.external_macro_backtrace,
                                    &db.styled_message(),
                                    &db.code,
                                    &primary_span,
@@ -798,7 +798,7 @@ impl EmitterWriter {
                 level: Level::Note,
                 message: vec![
                     (["this error originates in a macro outside of the current crate",
-                      "(run with -Z macro-backtrace for more info)"].join(" "),
+                      "(run with -Z external-macro-backtrace for more info)"].join(" "),
                      Style::NoStyle),
                 ],
                 span: MultiSpan::new(),
@@ -888,7 +888,7 @@ impl EmitterWriter {
                             msg: &Vec<(String, Style)>,
                             code: &Option<DiagnosticId>,
                             level: &Level,
-                            macro_backtrace: bool,
+                            external_macro_backtrace: bool,
                             max_line_num_len: usize,
                             is_secondary: bool)
                             -> io::Result<()> {
@@ -1086,7 +1086,7 @@ impl EmitterWriter {
             }
         }
 
-        if macro_backtrace {
+        if external_macro_backtrace {
             if let Some(ref primary_span) = msp.primary_span().as_ref() {
                 self.render_macro_backtrace_old_school(primary_span, &mut buffer)?;
             }
@@ -1183,7 +1183,7 @@ impl EmitterWriter {
     }
     fn emit_messages_default(&mut self,
                              level: &Level,
-                             macro_backtrace: bool,
+                             external_macro_backtrace: bool,
                              message: &Vec<(String, Style)>,
                              code: &Option<DiagnosticId>,
                              span: &MultiSpan,
@@ -1196,7 +1196,7 @@ impl EmitterWriter {
                                         message,
                                         code,
                                         level,
-                                        macro_backtrace,
+                                        external_macro_backtrace,
                                         max_line_num_len,
                                         false) {
             Ok(()) => {
@@ -1218,7 +1218,7 @@ impl EmitterWriter {
                                                         &child.styled_message(),
                                                         &None,
                                                         &child.level,
-                                                        macro_backtrace,
+                                                        external_macro_backtrace,
                                                         max_line_num_len,
                                                         true) {
                             Err(e) => panic!("failed to emit error: {}", e),

src/librustc_errors/lib.rs

@@ -233,11 +233,10 @@ pub use diagnostic_builder::DiagnosticBuilder;
 /// (fatal, bug, unimpl) may cause immediate exit,
 /// others log errors for later reporting.
 pub struct Handler {
+    pub flags: HandlerFlags,
+
     err_count: Cell<usize>,
     emitter: RefCell<Box<Emitter>>,
-    pub can_emit_warnings: bool,
-    treat_err_as_bug: bool,
-    pub macro_backtrace: bool,
     continue_after_error: Cell<bool>,
     delayed_span_bug: RefCell<Option<Diagnostic>>,
     tracked_diagnostics: RefCell<Option<Vec<Diagnostic>>>,
@@ -248,28 +247,55 @@ pub struct Handler {
     emitted_diagnostics: RefCell<FxHashSet<u128>>,
 }
 
+#[derive(Default)]
+pub struct HandlerFlags {
+    pub can_emit_warnings: bool,
+    pub treat_err_as_bug: bool,
+    pub external_macro_backtrace: bool,
+}
+
 impl Handler {
     pub fn with_tty_emitter(color_config: ColorConfig,
                             can_emit_warnings: bool,
                             treat_err_as_bug: bool,
-                            macro_backtrace: bool,
                             cm: Option<Rc<CodeMapper>>)
                             -> Handler {
+        Handler::with_tty_emitter_and_flags(
+            color_config,
+            cm,
+            HandlerFlags {
+                can_emit_warnings,
+                treat_err_as_bug,
+                .. Default::default()
+            })
+    }
+
+    pub fn with_tty_emitter_and_flags(color_config: ColorConfig,
+                                      cm: Option<Rc<CodeMapper>>,
+                                      flags: HandlerFlags)
+                                      -> Handler {
         let emitter = Box::new(EmitterWriter::stderr(color_config, cm, false));
-        Handler::with_emitter(can_emit_warnings, treat_err_as_bug, macro_backtrace, emitter)
+        Handler::with_emitter_and_flags(emitter, flags)
     }
 
     pub fn with_emitter(can_emit_warnings: bool,
                         treat_err_as_bug: bool,
-                        macro_backtrace: bool,
                         e: Box<Emitter>)
                         -> Handler {
+        Handler::with_emitter_and_flags(
+            e,
+            HandlerFlags {
+                can_emit_warnings,
+                treat_err_as_bug,
+                .. Default::default()
+            })
+    }
+
+    pub fn with_emitter_and_flags(e: Box<Emitter>, flags: HandlerFlags) -> Handler {
         Handler {
+            flags,
             err_count: Cell::new(0),
             emitter: RefCell::new(e),
-            can_emit_warnings,
-            treat_err_as_bug,
-            macro_backtrace,
             continue_after_error: Cell::new(true),
             delayed_span_bug: RefCell::new(None),
             tracked_diagnostics: RefCell::new(None),
@@ -297,7 +323,7 @@ impl Handler {
                                                     -> DiagnosticBuilder<'a> {
         let mut result = DiagnosticBuilder::new(self, Level::Warning, msg);
         result.set_span(sp);
-        if !self.can_emit_warnings {
+        if !self.flags.can_emit_warnings {
             result.cancel();
         }
         result
@@ -310,14 +336,14 @@ impl Handler {
         let mut result = DiagnosticBuilder::new(self, Level::Warning, msg);
         result.set_span(sp);
         result.code(code);
-        if !self.can_emit_warnings {
+        if !self.flags.can_emit_warnings {
             result.cancel();
         }
         result
     }
     pub fn struct_warn<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
         let mut result = DiagnosticBuilder::new(self, Level::Warning, msg);
-        if !self.can_emit_warnings {
+        if !self.flags.can_emit_warnings {
             result.cancel();
         }
         result
@@ -380,7 +406,7 @@ impl Handler {
     }
 
     fn panic_if_treat_err_as_bug(&self) {
-        if self.treat_err_as_bug {
+        if self.flags.treat_err_as_bug {
             panic!("encountered error with `-Z treat_err_as_bug");
         }
     }
@@ -422,7 +448,7 @@ impl Handler {
         panic!(ExplicitBug);
     }
     pub fn delay_span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) {
-        if self.treat_err_as_bug {
+        if self.flags.treat_err_as_bug {
             self.span_bug(sp, msg);
         }
         let mut diagnostic = Diagnostic::new(Level::Bug, msg);
@@ -447,15 +473,15 @@ impl Handler {
         self.span_bug(sp, &format!("unimplemented {}", msg));
     }
     pub fn fatal(&self, msg: &str) -> FatalError {
-        if self.treat_err_as_bug {
+        if self.flags.treat_err_as_bug {
             self.bug(msg);
         }
         let mut db = DiagnosticBuilder::new(self, Fatal, msg);
         db.emit();
         FatalError
     }
     pub fn err(&self, msg: &str) {
-        if self.treat_err_as_bug {
+        if self.flags.treat_err_as_bug {
             self.bug(msg);
         }
         let mut db = DiagnosticBuilder::new(self, Error, msg);
@@ -508,7 +534,7 @@ impl Handler {
         panic!(self.fatal(&s));
     }
     pub fn emit(&self, msp: &MultiSpan, msg: &str, lvl: Level) {
-        if lvl == Warning && !self.can_emit_warnings {
+        if lvl == Warning && !self.flags.can_emit_warnings {
             return;
         }
         let mut db = DiagnosticBuilder::new(self, lvl, msg);
@@ -519,7 +545,7 @@ impl Handler {
         }
     }
     pub fn emit_with_code(&self, msp: &MultiSpan, msg: &str, code: DiagnosticId, lvl: Level) {
-        if lvl == Warning && !self.can_emit_warnings {
+        if lvl == Warning && !self.flags.can_emit_warnings {
             return;
         }
         let mut db = DiagnosticBuilder::new_with_code(self, lvl, Some(code), msg);

src/librustc_trans/back/write.rs

@@ -353,7 +353,7 @@ pub struct CodegenContext {
 
 impl CodegenContext {
     pub fn create_diag_handler(&self) -> Handler {
-        Handler::with_emitter(true, false, false, Box::new(self.diag_emitter.clone()))
+        Handler::with_emitter(true, false, Box::new(self.diag_emitter.clone()))
     }
 
     pub fn config(&self, kind: ModuleKind) -> &ModuleConfig {

src/librustdoc/core.rs

@@ -141,7 +141,6 @@ pub fn run_core(search_paths: SearchPaths,
     let diagnostic_handler = errors::Handler::with_tty_emitter(ColorConfig::Auto,
                                                                true,
                                                                false,
-                                                               false,
                                                                Some(codemap.clone()));
 
     let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader));

src/librustdoc/test.rs

@@ -82,7 +82,7 @@ pub fn run(input: &str,
     let codemap = Rc::new(CodeMap::new(sessopts.file_path_mapping()));
     let handler =
         errors::Handler::with_tty_emitter(ColorConfig::Auto,
-                                          true, false, false,
+                                          true, false,
                                           Some(codemap.clone()));
 
     let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader));
@@ -246,7 +246,7 @@ fn run_test(test: &str, cratename: &str, filename: &str, cfgs: Vec<String>, libs
     let _bomb = Bomb(data.clone(), old.unwrap_or(box io::stdout()));
 
     // Compile the code
-    let diagnostic_handler = errors::Handler::with_emitter(true, false, false, box emitter);
+    let diagnostic_handler = errors::Handler::with_emitter(true, false, box emitter);
 
     let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader));
     let mut sess = session::build_session_(

src/libsyntax/parse/lexer/mod.rs

@@ -1726,7 +1726,7 @@ mod tests {
                                                           Some(cm.clone()),
                                                           false);
         ParseSess {
-            span_diagnostic: errors::Handler::with_emitter(true, false, false, Box::new(emitter)),
+            span_diagnostic: errors::Handler::with_emitter(true, false, Box::new(emitter)),
             unstable_features: UnstableFeatures::from_environment(),
             config: CrateConfig::new(),
             included_mod_stack: RefCell::new(Vec::new()),

src/libsyntax/parse/mod.rs

@@ -58,7 +58,6 @@ impl ParseSess {
         let handler = Handler::with_tty_emitter(ColorConfig::Auto,
                                                 true,
                                                 false,
-                                                false,
                                                 Some(cm.clone()));
         ParseSess::with_span_handler(handler, cm)
     }