make old school mode a bit more configurable

diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index bfd7853d41e2709e3c950a0c8c42050ae4b74b61..77259cea24d28265ddac5472e72fb52bb35afe33 100644 (file)
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -454,7 +454,10 @@ pub fn build_session_with_codemap(sopts: config::Options,
 
     let emitter: Box<Emitter> = match sopts.error_format {
         config::ErrorOutputType::HumanReadable(color_config) => {
-            Box::new(EmitterWriter::stderr(color_config, Some(registry), codemap.clone()))
+            Box::new(EmitterWriter::stderr(color_config,
+                                           Some(registry),
+                                           codemap.clone(),
+                                           errors::snippet::FormatMode::EnvironmentSelected))
         }
         config::ErrorOutputType::Json => {
             Box::new(JsonEmitter::stderr(Some(registry), codemap.clone()))

diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index d46a8f3c453d6ba15fb05d066b5fdc35af11e65d..a7c68e3a87b318f418f41ff688894afb493ea3a9 100644 (file)
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -17,7 +17,7 @@
 use {Level, RenderSpan, CodeSuggestion, DiagnosticBuilder, CodeMapper};
 use RenderSpan::*;
 use Level::*;
-use snippet::{RenderedLineKind, SnippetData, Style};
+use snippet::{RenderedLineKind, SnippetData, Style, FormatMode};
 
 use std::{cmp, fmt};
 use std::io::prelude::*;
@@ -159,7 +159,7 @@ pub struct EmitterWriter {
     first: bool,
 
     // For now, allow an old-school mode while we transition
-    old_school: bool,
+    format_mode: FormatMode
 }
 
 impl CoreEmitter for EmitterWriter {
@@ -194,35 +194,35 @@ macro_rules! println_maybe_styled {
 impl EmitterWriter {
     pub fn stderr(color_config: ColorConfig,
                   registry: Option<registry::Registry>,
-                  code_map: Rc<CodeMapper>)
+                  code_map: Rc<CodeMapper>,
+                  format_mode: FormatMode)
                   -> EmitterWriter {
-        let old_school = check_old_skool();
         if color_config.use_color() {
             let dst = Destination::from_stderr();
             EmitterWriter { dst: dst,
                             registry: registry,
                             cm: code_map,
                             first: true,
-                            old_school: old_school }
+                            format_mode: format_mode.clone() }
         } else {
             EmitterWriter { dst: Raw(Box::new(io::stderr())),
                             registry: registry,
                             cm: code_map,
                             first: true,
-                            old_school: old_school }
+                            format_mode: format_mode.clone() }
         }
     }
 
     pub fn new(dst: Box<Write + Send>,
                registry: Option<registry::Registry>,
-               code_map: Rc<CodeMapper>)
+               code_map: Rc<CodeMapper>,
+               format_mode: FormatMode)
                -> EmitterWriter {
-        let old_school = check_old_skool();
         EmitterWriter { dst: Raw(dst),
                         registry: registry,
                         cm: code_map,
                         first: true,
-                        old_school: old_school }
+                        format_mode: format_mode.clone() }
     }
 
     fn emit_message_(&mut self,
@@ -233,11 +233,17 @@ fn emit_message_(&mut self,
                      is_header: bool,
                      show_snippet: bool)
                      -> io::Result<()> {
+        let old_school = match self.format_mode {
+            FormatMode::NewErrorFormat => false,
+            FormatMode::OriginalErrorFormat => true,
+            FormatMode::EnvironmentSelected => check_old_skool()
+        };
+
         if is_header {
             if self.first {
                 self.first = false;
             } else {
-                if !self.old_school {
+                if !old_school {
                     write!(self.dst, "\n")?;
                 }
             }
@@ -248,7 +254,7 @@ fn emit_message_(&mut self,
                                        .and_then(|registry| registry.find_description(code))
                                        .is_some() => {
                 let code_with_explain = String::from("--explain ") + code;
-                if self.old_school {
+                if old_school {
                     let loc = match rsp.span().primary_span() {
                         Some(COMMAND_LINE_SP) | Some(DUMMY_SP) => "".to_string(),
                         Some(ps) => self.cm.span_to_string(ps),
@@ -261,7 +267,7 @@ fn emit_message_(&mut self,
                 }
             }
             _ => {
-                if self.old_school {
+                if old_school {
                     let loc = match rsp.span().primary_span() {
                         Some(COMMAND_LINE_SP) | Some(DUMMY_SP) => "".to_string(),
                         Some(ps) => self.cm.span_to_string(ps),
@@ -303,7 +309,7 @@ fn emit_message_(&mut self,
                 }
             }
         }
-        if self.old_school {
+        if old_school {
             match code {
                 Some(code) if self.registry.as_ref()
                                         .and_then(|registry| registry.find_description(code))
@@ -363,14 +369,22 @@ pub fn highlight_lines(&mut self,
                        lvl: Level)
                        -> io::Result<()>
     {
+        let old_school = match self.format_mode {
+            FormatMode::NewErrorFormat => false,
+            FormatMode::OriginalErrorFormat => true,
+            FormatMode::EnvironmentSelected => check_old_skool()
+        };
+
         let mut snippet_data = SnippetData::new(self.cm.clone(),
-                                                msp.primary_span());
-        if self.old_school {
+                                                msp.primary_span(),
+                                                self.format_mode.clone());
+        if old_school {
             let mut output_vec = vec![];
 
             for span_label in msp.span_labels() {
                 let mut snippet_data = SnippetData::new(self.cm.clone(),
-                                                        Some(span_label.span));
+                                                        Some(span_label.span),
+                                                        self.format_mode.clone());
 
                 snippet_data.push(span_label.span,
                                   span_label.is_primary,

diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs
index 47047769d31f8db57103c803b77982b41b9413c2..18fc826f9aa4bc5840fb8e7b05c10732c07ab33b 100644 (file)
--- a/src/librustc_errors/lib.rs
+++ b/src/librustc_errors/lib.rs
@@ -425,7 +425,8 @@ pub fn with_tty_emitter(color_config: ColorConfig,
                             treat_err_as_bug: bool,
                             cm: Rc<CodeMapper>)
                             -> Handler {
-        let emitter = Box::new(EmitterWriter::stderr(color_config, registry, cm));
+        let emitter = Box::new(EmitterWriter::stderr(color_config, registry, cm,
+                               snippet::FormatMode::EnvironmentSelected));
         Handler::with_emitter(can_emit_warnings, treat_err_as_bug, emitter)
     }
 

diff --git a/src/librustc_errors/snippet.rs b/src/librustc_errors/snippet.rs
index c472994599ccb40ee0dc659ec5fa5a0a2f12be55..33f40ffc71a9f69b78b965db5c2f7cb066503e4c 100644 (file)
--- a/src/librustc_errors/snippet.rs
+++ b/src/librustc_errors/snippet.rs
@@ -17,10 +17,18 @@
 use std::rc::Rc;
 use std::mem;
 
+#[derive(Clone)]
+pub enum FormatMode {
+    NewErrorFormat,
+    OriginalErrorFormat,
+    EnvironmentSelected
+}
+
 #[derive(Clone)]
 pub struct SnippetData {
     codemap: Rc<CodeMapper>,
     files: Vec<FileInfo>,
+    format_mode: FormatMode,
 }
 
 #[derive(Clone)]
@@ -35,6 +43,10 @@ pub struct FileInfo {
     primary_span: Option<Span>,
 
     lines: Vec<Line>,
+
+    /// The type of error format to render.  We keep it here so that
+    /// it's easy to configure for both tests and regular usage
+    format_mode: FormatMode,
 }
 
 #[derive(Clone, Debug)]
@@ -111,7 +123,8 @@ pub enum RenderedLineKind {
 
 impl SnippetData {
     pub fn new(codemap: Rc<CodeMapper>,
-               primary_span: Option<Span>) // (*)
+               primary_span: Option<Span>,
+               format_mode: FormatMode) // (*)
                -> Self {
         // (*) The primary span indicates the file that must appear
         // first, and which will have a line number etc in its
@@ -125,7 +138,8 @@ pub fn new(codemap: Rc<CodeMapper>,
 
         let mut data = SnippetData {
             codemap: codemap.clone(),
-            files: vec![]
+            files: vec![],
+            format_mode: format_mode.clone()
         };
         if let Some(primary_span) = primary_span {
             let lo = codemap.lookup_char_pos(primary_span.lo);
@@ -134,6 +148,7 @@ pub fn new(codemap: Rc<CodeMapper>,
                     file: lo.file,
                     primary_span: Some(primary_span),
                     lines: vec![],
+                    format_mode: format_mode.clone(),
                 });
         }
         data
@@ -166,6 +181,7 @@ fn file(&mut self, file_map: &Rc<FileMap>) -> &mut FileInfo {
                 file: file_map.clone(),
                 lines: vec![],
                 primary_span: None,
+                format_mode: self.format_mode.clone()
             });
         self.files.last_mut().unwrap()
     }
@@ -177,7 +193,7 @@ pub fn render_lines(&self) -> Vec<RenderedLine> {
             self.files.iter()
                       .flat_map(|f| f.render_file_lines(&self.codemap))
                       .collect();
-        prepend_prefixes(&mut rendered_lines);
+        prepend_prefixes(&mut rendered_lines, &self.format_mode);
         trim_lines(&mut rendered_lines);
         rendered_lines
     }
@@ -454,7 +470,11 @@ fn ensure_source_line(&mut self, line_index: usize) -> usize {
     }
 
     fn render_file_lines(&self, codemap: &Rc<CodeMapper>) -> Vec<RenderedLine> {
-        let old_school = check_old_skool();
+        let old_school = match self.format_mode {
+            FormatMode::OriginalErrorFormat => true,
+            FormatMode::NewErrorFormat => false,
+            FormatMode::EnvironmentSelected => check_old_skool()
+        };
 
         // As a first step, we elide any instance of more than one
         // continuous unannotated line.
@@ -590,7 +610,12 @@ fn render_file_lines(&self, codemap: &Rc<CodeMapper>) -> Vec<RenderedLine> {
     }
 
     fn render_line(&self, line: &Line) -> Vec<RenderedLine> {
-        let old_school = check_old_skool();
+        let old_school = match self.format_mode {
+            FormatMode::OriginalErrorFormat => true,
+            FormatMode::NewErrorFormat => false,
+            FormatMode::EnvironmentSelected => check_old_skool()
+        };
+
         let source_string = self.file.get_line(line.line_index)
                                      .unwrap_or("");
         let source_kind = RenderedLineKind::SourceText {
@@ -775,8 +800,12 @@ fn render_line(&self, line: &Line) -> Vec<RenderedLine> {
     }
 }
 
-fn prepend_prefixes(rendered_lines: &mut [RenderedLine]) {
-    let old_school = check_old_skool();
+fn prepend_prefixes(rendered_lines: &mut [RenderedLine], format_mode: &FormatMode) {
+    let old_school = match *format_mode {
+        FormatMode::OriginalErrorFormat => true,
+        FormatMode::NewErrorFormat => false,
+        FormatMode::EnvironmentSelected => check_old_skool()
+    };
     if old_school {
         return;
     }

diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index f98478a000a47dfa622eff1ed50a3ad9bd543bcc..766f27dc0a99f88b382c140963cd93449c59f74b 100644 (file)
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -830,7 +830,7 @@ mod tests {
     use syntax_pos::*;
     use errors::{Level, CodeSuggestion};
     use errors::emitter::EmitterWriter;
-    use errors::snippet::{SnippetData, RenderedLine};
+    use errors::snippet::{SnippetData, RenderedLine, FormatMode};
     use std::sync::{Arc, Mutex};
     use std::io::{self, Write};
     use std::str::from_utf8;
@@ -1234,7 +1234,10 @@ fn flush(&mut self) -> io::Result<()> { Ok(()) }
     fn test_hilight_suggestion_issue_11715() {
         let data = Arc::new(Mutex::new(Vec::new()));
         let cm = Rc::new(CodeMap::new());
-        let mut ew = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone());
+        let mut ew = EmitterWriter::new(Box::new(Sink(data.clone())),
+                                        None,
+                                        cm.clone(),
+                                        FormatMode::NewErrorFormat);
         let content = "abcdefg
         koksi
         line3
@@ -1317,7 +1320,10 @@ fn test_multi_span_splice() {
     fn test_multispan_highlight() {
         let data = Arc::new(Mutex::new(Vec::new()));
         let cm = Rc::new(CodeMap::new());
-        let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone());
+        let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())),
+                                          None,
+                                          cm.clone(),
+                                          FormatMode::NewErrorFormat);
 
         let inp =       "_____aaaaaa____bbbbbb__cccccdd_";
         let sp1 =       "     ~~~~~~                    ";
@@ -1370,7 +1376,10 @@ fn test_multispan_highlight() {
     fn test_huge_multispan_highlight() {
         let data = Arc::new(Mutex::new(Vec::new()));
         let cm = Rc::new(CodeMap::new());
-        let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())), None, cm.clone());
+        let mut diag = EmitterWriter::new(Box::new(Sink(data.clone())),
+                                          None,
+                                          cm.clone(),
+                                          FormatMode::NewErrorFormat);
 
         let inp = "aaaaa\n\
                    aaaaa\n\
@@ -1462,7 +1471,7 @@ fn foo() {
         let foo = cm.new_filemap_and_lines("foo.rs", None, file_text);
         let span_bar = cm.span_substr(&foo, file_text, "bar", 0);
 
-        let mut snippet = SnippetData::new(cm, Some(span_bar));
+        let mut snippet = SnippetData::new(cm, Some(span_bar), FormatMode::NewErrorFormat);
         snippet.push(span_bar, true, None);
 
         let lines = snippet.render_lines();
@@ -1489,7 +1498,7 @@ fn foo() {
         let span_vec1 = cm.span_substr(&foo, file_text, "vec", 1);
         let span_semi = cm.span_substr(&foo, file_text, ";", 0);
 
-        let mut snippet = SnippetData::new(cm, None);
+        let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat);
         snippet.push(span_vec0, false, Some(format!("previous borrow of `vec` occurs here")));
         snippet.push(span_vec1, false, Some(format!("error occurs here")));
         snippet.push(span_semi, false, Some(format!("previous borrow ends here")));
@@ -1554,7 +1563,7 @@ fn bar() {
         let span_bar_vec1 = cm.span_substr(&bar_map, file_text_bar, "vec", 1);
         let span_bar_semi = cm.span_substr(&bar_map, file_text_bar, ";", 0);
 
-        let mut snippet = SnippetData::new(cm, Some(span_foo_vec1));
+        let mut snippet = SnippetData::new(cm, Some(span_foo_vec1), FormatMode::NewErrorFormat);
         snippet.push(span_foo_vec0, false, Some(format!("a")));
         snippet.push(span_foo_vec1, true, Some(format!("b")));
         snippet.push(span_foo_semi, false, Some(format!("c")));
@@ -1611,7 +1620,7 @@ fn foo() {
         let span_data1 = cm.span_substr(&foo, file_text, "data", 1);
         let span_rbrace = cm.span_substr(&foo, file_text, "}", 3);
 
-        let mut snippet = SnippetData::new(cm, None);
+        let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat);
         snippet.push(span_data0, false, Some(format!("immutable borrow begins here")));
         snippet.push(span_data1, false, Some(format!("mutable borrow occurs here")));
         snippet.push(span_rbrace, false, Some(format!("immutable borrow ends here")));
@@ -1651,7 +1660,7 @@ fn foo() {
         let span2 = cm.span_substr(&foo, file_text, "ec.push", 0);
         let span3 = cm.span_substr(&foo, file_text, "unwrap", 0);
 
-        let mut snippet = SnippetData::new(cm, None);
+        let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat);
         snippet.push(span0, false, Some(format!("A")));
         snippet.push(span1, false, Some(format!("B")));
         snippet.push(span2, false, Some(format!("C")));
@@ -1689,7 +1698,7 @@ fn foo() {
         let span_semi = cm.span_substr(&foo, file_text, ";", 0);
 
         // intentionally don't push the snippets left to right
-        let mut snippet = SnippetData::new(cm, None);
+        let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat);
         snippet.push(span_vec1, false, Some(format!("error occurs here")));
         snippet.push(span_vec0, false, Some(format!("previous borrow of `vec` occurs here")));
         snippet.push(span_semi, false, Some(format!("previous borrow ends here")));
@@ -1729,7 +1738,7 @@ fn foo() {
         let span_vec0 = cm.span_substr(&foo, file_text, "vec", 3);
         let span_vec1 = cm.span_substr(&foo, file_text, "vec", 8);
 
-        let mut snippet = SnippetData::new(cm, None);
+        let mut snippet = SnippetData::new(cm, None, FormatMode::NewErrorFormat);
         snippet.push(span_vec0, false, Some(format!("`vec` moved here because it \
             has type `collections::vec::Vec<i32>`")));
         snippet.push(span_vec1, false, Some(format!("use of moved value: `vec`")));
@@ -1766,7 +1775,7 @@ fn foo() {
         let cm = Rc::new(CodeMap::new());
         let foo = cm.new_filemap_and_lines("foo.rs", None, file_text);
 
-        let mut snippet = SnippetData::new(cm.clone(), None);
+        let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat);
         for i in 0..4 {
             let span_veci = cm.span_substr(&foo, file_text, "vec", i);
             snippet.push(span_veci, false, None);
@@ -1800,7 +1809,7 @@ fn foo(x: u32) {
         let cm = Rc::new(CodeMap::new());
         let foo = cm.new_filemap_and_lines("foo.rs", None, file_text);
 
-        let mut snippet = SnippetData::new(cm.clone(), None);
+        let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat);
         let fn_span = cm.span_substr(&foo, file_text, "fn", 0);
         let rbrace_span = cm.span_substr(&foo, file_text, "}", 0);
         snippet.push(splice(fn_span, rbrace_span), false, None);
@@ -1829,7 +1838,7 @@ fn foo(x: u32) {
         let cm = Rc::new(CodeMap::new());
         let foo = cm.new_filemap_and_lines("foo.rs", None, file_text);
 
-        let mut snippet = SnippetData::new(cm.clone(), None);
+        let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat);
         let fn_span = cm.span_substr(&foo, file_text, "fn foo(x: u32)", 0);
         let x_span = cm.span_substr(&foo, file_text, "x", 0);
         snippet.push(fn_span, false, Some(format!("fn_span")));
@@ -1864,7 +1873,7 @@ fn foo(x: u32) {
         let cm = Rc::new(CodeMap::new());
         let foo = cm.new_filemap_and_lines("foo.rs", None, file_text);
 
-        let mut snippet = SnippetData::new(cm.clone(), None);
+        let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat);
         let fn_span = cm.span_substr(&foo, file_text, "fn foo(x", 0);
         let x_span = cm.span_substr(&foo, file_text, "x: u32)", 0);
         snippet.push(fn_span, false, Some(format!("fn_span")));
@@ -1902,7 +1911,7 @@ fn foo() {
         let cm = Rc::new(CodeMap::new());
         let foo = cm.new_filemap_and_lines("foo.rs", None, file_text);
 
-        let mut snippet = SnippetData::new(cm.clone(), None);
+        let mut snippet = SnippetData::new(cm.clone(), None, FormatMode::NewErrorFormat);
 
         let closure_span = {
             let closure_start_span = cm.span_substr(&foo, file_text, "||", 0);
@@ -1954,7 +1963,9 @@ unsafe impl Send for &'static Foo {
         let mut rbrace_span = cm.span_substr(&foo, file_text, "}", 1);
         rbrace_span.lo = rbrace_span.hi;
 
-        let mut snippet = SnippetData::new(cm.clone(), Some(rbrace_span));
+        let mut snippet = SnippetData::new(cm.clone(),
+                                           Some(rbrace_span),
+                                           FormatMode::NewErrorFormat);
         snippet.push(rbrace_span, false, None);
         let lines = snippet.render_lines();
         let text: String = make_string(&lines);

diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
index d9d4bb504a77dfb06fa7a9a693bb6599346cb7de..809f4daa3616d7a481dace362d62e59499668db0 100644 (file)
--- a/src/libsyntax/parse/lexer/mod.rs
+++ b/src/libsyntax/parse/lexer/mod.rs
@@ -1687,7 +1687,10 @@ mod tests {
 
     fn mk_sh(cm: Rc<CodeMap>) -> errors::Handler {
         // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-        let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()), None, cm);
+        let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()),
+                                                None,
+                                                cm,
+                                                errors::snippet::FormatMode::EnvironmentSelected);
         errors::Handler::with_emitter(true, false, Box::new(emitter))
     }