Add in styled_buffer.rs and remove some unused code

Author: Jonathan Turner

src/librustc/infer/error_reporting.rs

@@ -94,7 +94,7 @@ use syntax::ast;
 use syntax::parse::token;
 use syntax::ptr::P;
 use syntax_pos::{self, Pos, Span};
-use errors::{DiagnosticBuilder, check_old_skool};
+use errors::{DiagnosticBuilder, check_old_school};
 
 impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn note_and_explain_region(self,
@@ -485,7 +485,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                                        "{}",
                                        trace.origin);
 
-        if !is_simple_error || check_old_skool() {
+        if !is_simple_error || check_old_school() {
             err.note_expected_found(&"type", &expected, &found);
         }
 

src/librustc_errors/emitter.rs

@@ -13,7 +13,7 @@ use self::Destination::*;
 use syntax_pos::{COMMAND_LINE_SP, DUMMY_SP, FileMap, Span, MultiSpan, LineInfo, CharPos};
 use registry;
 
-use check_old_skool;
+use check_old_school;
 use {Level, CodeSuggestion, DiagnosticBuilder, CodeMapper};
 use RenderSpan::*;
 use snippet::{StyledString, Style, FormatMode, Annotation, Line};
@@ -36,7 +36,7 @@ impl Emitter for EmitterWriter {
         let old_school = match self.format_mode {
             FormatMode::NewErrorFormat => false,
             FormatMode::OriginalErrorFormat => true,
-            FormatMode::EnvironmentSelected => check_old_skool()
+            FormatMode::EnvironmentSelected => check_old_school()
         };
 
         if old_school {
@@ -243,59 +243,32 @@ impl EmitterWriter {
         // For this reason, we group the lines into "highlight lines"
         // and "annotations lines", where the highlight lines have the `~`.
 
-        // let mut highlight_line = Self::whitespace(&source_string);
-        let old_school = check_old_skool();
-
         // Sort the annotations by (start, end col)
         let mut annotations = line.annotations.clone();
         annotations.sort();
 
         // Next, create the highlight line.
         for annotation in &annotations {
-            if old_school {
-                for p in annotation.start_col..annotation.end_col {
-                    if p == annotation.start_col {
-                        buffer.putc(line_offset + 1,
-                                    width_offset + p,
-                                    '^',
-                                    if annotation.is_primary {
-                                        Style::UnderlinePrimary
-                                    } else {
-                                        Style::OldSchoolNote
-                                    });
-                    } else {
-                        buffer.putc(line_offset + 1,
-                                    width_offset + p,
-                                    '~',
-                                    if annotation.is_primary {
-                                        Style::UnderlinePrimary
-                                    } else {
-                                        Style::OldSchoolNote
-                                    });
+            for p in annotation.start_col..annotation.end_col {
+                if annotation.is_primary {
+                    buffer.putc(line_offset + 1,
+                                width_offset + p,
+                                '^',
+                                Style::UnderlinePrimary);
+                    if !annotation.is_minimized {
+                        buffer.set_style(line_offset,
+                                            width_offset + p,
+                                            Style::UnderlinePrimary);
                     }
-                }
-            } else {
-                for p in annotation.start_col..annotation.end_col {
-                    if annotation.is_primary {
-                        buffer.putc(line_offset + 1,
-                                    width_offset + p,
-                                    '^',
-                                    Style::UnderlinePrimary);
-                        if !annotation.is_minimized {
-                            buffer.set_style(line_offset,
-                                                width_offset + p,
-                                                Style::UnderlinePrimary);
-                        }
-                    } else {
-                        buffer.putc(line_offset + 1,
-                                    width_offset + p,
-                                    '-',
-                                    Style::UnderlineSecondary);
-                        if !annotation.is_minimized {
-                            buffer.set_style(line_offset,
-                                                width_offset + p,
-                                                Style::UnderlineSecondary);
-                        }
+                } else {
+                    buffer.putc(line_offset + 1,
+                                width_offset + p,
+                                '-',
+                                Style::UnderlineSecondary);
+                    if !annotation.is_minimized {
+                        buffer.set_style(line_offset,
+                                            width_offset + p,
+                                            Style::UnderlineSecondary);
                     }
                 }
             }
@@ -311,10 +284,6 @@ impl EmitterWriter {
         if labeled_annotations.is_empty() {
             return;
         }
-        if old_school {
-            return;
-        }
-
         // Now add the text labels. We try, when possible, to stick the rightmost
         // annotation at the end of the highlight line:
         //

src/librustc_errors/lib.rs

@@ -756,13 +756,13 @@ pub fn expect<T, M>(diag: &Handler, opt: Option<T>, msg: M) -> T where
 ///
 /// FIXME(#33240)
 #[cfg(not(test))]
-pub fn check_old_skool() -> bool {
+pub fn check_old_school() -> bool {
     use std::env;
     env::var("RUST_NEW_ERROR_FORMAT").is_err()
 }
 
 /// For unit tests, use the new format.
 #[cfg(test)]
-pub fn check_old_skool() -> bool {
+pub fn check_old_school() -> bool {
     false
 }

src/librustc_errors/styled_buffer.rs

@@ -0,0 +1,133 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Code for creating styled buffers
+
+use snippet::{Style, StyledString};
+
+#[derive(Debug)]
+pub struct StyledBuffer {
+    text: Vec<Vec<char>>,
+    styles: Vec<Vec<Style>>,
+}
+
+impl StyledBuffer {
+    pub fn new() -> StyledBuffer {
+        StyledBuffer {
+            text: vec![],
+            styles: vec![],
+        }
+    }
+
+    pub fn render(&self) -> Vec<Vec<StyledString>> {
+        let mut output: Vec<Vec<StyledString>> = vec![];
+        let mut styled_vec: Vec<StyledString> = vec![];
+
+        for (row, row_style) in self.text.iter().zip(&self.styles) {
+            let mut current_style = Style::NoStyle;
+            let mut current_text = String::new();
+
+            for (&c, &s) in row.iter().zip(row_style) {
+                if s != current_style {
+                    if !current_text.is_empty() {
+                        styled_vec.push(StyledString {
+                            text: current_text,
+                            style: current_style,
+                        });
+                    }
+                    current_style = s;
+                    current_text = String::new();
+                }
+                current_text.push(c);
+            }
+            if !current_text.is_empty() {
+                styled_vec.push(StyledString {
+                    text: current_text,
+                    style: current_style,
+                });
+            }
+
+            // We're done with the row, push and keep going
+            output.push(styled_vec);
+
+            styled_vec = vec![];
+        }
+
+        output
+    }
+
+    fn ensure_lines(&mut self, line: usize) {
+        while line >= self.text.len() {
+            self.text.push(vec![]);
+            self.styles.push(vec![]);
+        }
+    }
+
+    pub fn putc(&mut self, line: usize, col: usize, chr: char, style: Style) {
+        self.ensure_lines(line);
+        if col < self.text[line].len() {
+            self.text[line][col] = chr;
+            self.styles[line][col] = style;
+        } else {
+            let mut i = self.text[line].len();
+            while i < col {
+                let s = match self.text[0].get(i) {
+                    Some(&'\t') => '\t',
+                    _ => ' ',
+                };
+                self.text[line].push(s);
+                self.styles[line].push(Style::NoStyle);
+                i += 1;
+            }
+            self.text[line].push(chr);
+            self.styles[line].push(style);
+        }
+    }
+
+    pub fn puts(&mut self, line: usize, col: usize, string: &str, style: Style) {
+        let mut n = col;
+        for c in string.chars() {
+            self.putc(line, n, c, style);
+            n += 1;
+        }
+    }
+
+    pub fn set_style(&mut self, line: usize, col: usize, style: Style) {
+        if self.styles.len() > line && self.styles[line].len() > col {
+            self.styles[line][col] = style;
+        }
+    }
+
+    pub fn prepend(&mut self, line: usize, string: &str, style: Style) {
+        self.ensure_lines(line);
+        let string_len = string.len();
+
+        // Push the old content over to make room for new content
+        for _ in 0..string_len {
+            self.styles[line].insert(0, Style::NoStyle);
+            self.text[line].insert(0, ' ');
+        }
+
+        self.puts(line, 0, string, style);
+    }
+
+    pub fn append(&mut self, line: usize, string: &str, style: Style) {
+        if line >= self.text.len() {
+            self.puts(line, 0, string, style);
+        } else {
+            let col = self.text[line].len();
+            self.puts(line, col, string, style);
+        }
+    }
+
+    pub fn num_lines(&self) -> usize {
+        self.text.len()
+    }
+}