// 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 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use self::Destination::*; use codemap::{self, COMMAND_LINE_SP, DUMMY_SP, Pos, Span, MultiSpan}; use diagnostics; use errors::{Level, RenderSpan, CodeSuggestion, DiagnosticBuilder}; use errors::RenderSpan::*; use errors::Level::*; use std::{cmp, fmt}; use std::io::prelude::*; use std::io; use std::rc::Rc; use term; pub trait Emitter { fn emit(&mut self, span: Option<&MultiSpan>, msg: &str, code: Option<&str>, lvl: Level); fn custom_emit(&mut self, sp: &RenderSpan, msg: &str, lvl: Level); /// Emit a structured diagnostic. fn emit_struct(&mut self, db: &DiagnosticBuilder) { self.emit(db.span.as_ref(), &db.message, db.code.as_ref().map(|s| &**s), db.level); for child in &db.children { match child.render_span { Some(ref sp) => self.custom_emit(sp, &child.message, child.level), None => self.emit(child.span.as_ref(), &child.message, None, child.level), } } } } /// maximum number of lines we will print for each error; arbitrary. pub const MAX_HIGHLIGHT_LINES: usize = 6; /// maximum number of lines we will print for each span; arbitrary. const MAX_SP_LINES: usize = 6; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum ColorConfig { Auto, Always, Never, } impl ColorConfig { fn use_color(&self) -> bool { match *self { ColorConfig::Always => true, ColorConfig::Never => false, ColorConfig::Auto => stderr_isatty(), } } } /// A basic emitter for when we don't have access to a codemap or registry. Used /// for reporting very early errors, etc. pub struct BasicEmitter { dst: Destination, } impl Emitter for BasicEmitter { fn emit(&mut self, msp: Option<&MultiSpan>, msg: &str, code: Option<&str>, lvl: Level) { assert!(msp.is_none(), "BasicEmitter can't handle spans"); if let Err(e) = print_diagnostic(&mut self.dst, "", lvl, msg, code) { panic!("failed to print diagnostics: {:?}", e); } } fn custom_emit(&mut self, _: &RenderSpan, _: &str, _: Level) { panic!("BasicEmitter can't handle custom_emit"); } } impl BasicEmitter { pub fn stderr(color_config: ColorConfig) -> BasicEmitter { if color_config.use_color() { let dst = Destination::from_stderr(); BasicEmitter { dst: dst } } else { BasicEmitter { dst: Raw(Box::new(io::stderr())) } } } } pub struct EmitterWriter { dst: Destination, registry: Option, cm: Rc, } impl Emitter for EmitterWriter { fn emit(&mut self, msp: Option<&MultiSpan>, msg: &str, code: Option<&str>, lvl: Level) { let error = match msp.map(|s|(s.to_span_bounds(), s)) { Some((COMMAND_LINE_SP, msp)) => { self.emit_(&FileLine(msp.clone()), msg, code, lvl) }, Some((DUMMY_SP, _)) | None => print_diagnostic(&mut self.dst, "", lvl, msg, code), Some((_, msp)) => self.emit_(&FullSpan(msp.clone()), msg, code, lvl), }; if let Err(e) = error { panic!("failed to print diagnostics: {:?}", e); } } fn custom_emit(&mut self, rsp: &RenderSpan, msg: &str, lvl: Level) { if let Err(e) = self.emit_(rsp, msg, None, lvl) { panic!("failed to print diagnostics: {:?}", e); } } } /// Do not use this for messages that end in `\n` – use `println_maybe_styled` instead. See /// `EmitterWriter::print_maybe_styled` for details. macro_rules! print_maybe_styled { ($dst: expr, $style: expr, $($arg: tt)*) => { $dst.print_maybe_styled(format_args!($($arg)*), $style, false) } } macro_rules! println_maybe_styled { ($dst: expr, $style: expr, $($arg: tt)*) => { $dst.print_maybe_styled(format_args!($($arg)*), $style, true) } } impl EmitterWriter { pub fn stderr(color_config: ColorConfig, registry: Option, code_map: Rc) -> EmitterWriter { if color_config.use_color() { let dst = Destination::from_stderr(); EmitterWriter { dst: dst, registry: registry, cm: code_map } } else { EmitterWriter { dst: Raw(Box::new(io::stderr())), registry: registry, cm: code_map } } } pub fn new(dst: Box, registry: Option, code_map: Rc) -> EmitterWriter { EmitterWriter { dst: Raw(dst), registry: registry, cm: code_map } } fn emit_(&mut self, rsp: &RenderSpan, msg: &str, code: Option<&str>, lvl: Level) -> io::Result<()> { let msp = rsp.span(); let bounds = msp.to_span_bounds(); let ss = if bounds == COMMAND_LINE_SP { "".to_string() } else if let EndSpan(_) = *rsp { let span_end = Span { lo: bounds.hi, hi: bounds.hi, expn_id: bounds.expn_id}; self.cm.span_to_string(span_end) } else { self.cm.span_to_string(bounds) }; try!(print_diagnostic(&mut self.dst, &ss[..], lvl, msg, code)); match *rsp { FullSpan(_) => { try!(self.highlight_lines(msp, lvl)); try!(self.print_macro_backtrace(bounds)); } EndSpan(_) => { try!(self.end_highlight_lines(msp, lvl)); try!(self.print_macro_backtrace(bounds)); } Suggestion(ref suggestion) => { try!(self.highlight_suggestion(suggestion)); try!(self.print_macro_backtrace(bounds)); } FileLine(..) => { // no source text in this case! } } if let Some(code) = code { if let Some(_) = self.registry.as_ref() .and_then(|registry| registry.find_description(code)) { try!(print_diagnostic(&mut self.dst, &ss[..], Help, &format!("run `rustc --explain {}` to see a \ detailed explanation", code), None)); } } Ok(()) } fn highlight_suggestion(&mut self, suggestion: &CodeSuggestion) -> io::Result<()> { let lines = self.cm.span_to_lines(suggestion.msp.to_span_bounds()).unwrap(); assert!(!lines.lines.is_empty()); let complete = suggestion.splice_lines(&self.cm); let line_count = cmp::min(lines.lines.len(), MAX_HIGHLIGHT_LINES); let display_lines = &lines.lines[..line_count]; let fm = &*lines.file; // Calculate the widest number to format evenly let max_digits = line_num_max_digits(display_lines.last().unwrap()); // print the suggestion without any line numbers, but leave // space for them. This helps with lining up with previous // snippets from the actual error being reported. let mut lines = complete.lines(); for line in lines.by_ref().take(MAX_HIGHLIGHT_LINES) { try!(write!(&mut self.dst, "{0}:{1:2$} {3}\n", fm.name, "", max_digits, line)); } // if we elided some lines, add an ellipsis if let Some(_) = lines.next() { try!(write!(&mut self.dst, "{0:1$} {0:2$} ...\n", "", fm.name.len(), max_digits)); } Ok(()) } fn highlight_lines(&mut self, msp: &MultiSpan, lvl: Level) -> io::Result<()> { let lines = match self.cm.span_to_lines(msp.to_span_bounds()) { Ok(lines) => lines, Err(_) => { try!(write!(&mut self.dst, "(internal compiler error: unprintable span)\n")); return Ok(()); } }; let fm = &*lines.file; if let None = fm.src { return Ok(()); } let display_line_infos = &lines.lines[..]; assert!(display_line_infos.len() > 0); // Calculate the widest number to format evenly and fix #11715 let digits = line_num_max_digits(display_line_infos.last().unwrap()); let first_line_index = display_line_infos.first().unwrap().line_index; let skip = fm.name.chars().count() + digits + 2; let mut spans = msp.spans.iter().peekable(); let mut lines = display_line_infos.iter(); let mut prev_line_index = first_line_index.wrapping_sub(1); // Display at most MAX_HIGHLIGHT_LINES lines. let mut remaining_err_lines = MAX_HIGHLIGHT_LINES; // To emit a overflowed spans code-lines *AFTER* the rendered spans let mut overflowed_buf = String::new(); let mut overflowed = false; // FIXME (#8706) 'l: loop { if remaining_err_lines <= 0 { break; } let line = match lines.next() { Some(l) => l, None => break, }; // Skip is the number of characters we need to skip because they are // part of the 'filename:line ' part of the code line. let mut s: String = ::std::iter::repeat(' ').take(skip).collect(); let mut col = skip; let mut lastc = ' '; let cur_line_str = fm.get_line(line.line_index).unwrap(); let mut line_chars = cur_line_str.chars().enumerate().peekable(); let mut line_spans = 0; // Assemble spans for this line loop { // Peek here to preserve the span if it doesn't belong to this line let sp = match spans.peek() { Some(sp) => **sp, None => break, }; let lo = self.cm.lookup_char_pos(sp.lo); let hi = self.cm.lookup_char_pos(sp.hi); let line_num = line.line_index + 1; if !(lo.line <= line_num && hi.line >= line_num) { // This line is not contained in the span if overflowed { // Never elide the final line of an overflowed span prev_line_index = line.line_index - 1; overflowed = false; break; } if line_spans == 0 { continue 'l; } else { // This line is finished, now render the spans we've assembled break; } } spans.next(); line_spans += 1; if lo.line != hi.line { // Assemble extra code lines to be emitted after this lines spans // (substract `2` because the first and last line are rendered normally) let max_lines = cmp::min(remaining_err_lines, MAX_SP_LINES) - 2; prev_line_index = line.line_index; let count = cmp::min((hi.line - lo.line - 1), max_lines); for _ in 0..count { let line = match lines.next() { Some(l) => l, None => break, }; let line_str = fm.get_line(line.line_index).unwrap(); overflowed_buf.push_str(&format!("{}:{:>width$} {}\n", fm.name, line.line_index + 1, line_str, width=digits)); remaining_err_lines -= 1; prev_line_index += 1 } // Remember that the span overflowed to ensure // that we emit its last line exactly once // (other spans may, or may not, start on it) overflowed = true; break; } for (pos, ch) in line_chars.by_ref() { lastc = ch; if pos >= lo.col.to_usize() { break; } // Whenever a tab occurs on the code line, we insert one on // the error-point-squiggly-line as well (instead of a space). // That way the squiggly line will usually appear in the correct // position. match ch { '\t' => { col += 8 - col%8; s.push('\t'); }, _ => { col += 1; s.push(' '); }, } } s.push('^'); let col_ptr = col; let count = match lastc { // Most terminals have a tab stop every eight columns by default '\t' => 8 - col%8, _ => 1, }; col += count; s.extend(::std::iter::repeat('~').take(count)); let hi = self.cm.lookup_char_pos(sp.hi); if hi.col != lo.col { let mut chars = line_chars.by_ref(); loop { // We peek here to preserve the value for the next span let (pos, ch) = match chars.peek() { Some(elem) => *elem, None => break, }; if pos >= hi.col.to_usize() { break; } let count = match ch { '\t' => 8 - col%8, _ => 1, }; col += count; s.extend(::std::iter::repeat('~').take(count)); chars.next(); } } if (col - col_ptr) > 0 { // One extra squiggly is replaced by a "^" s.pop(); } } // If we elided something put an ellipsis. if prev_line_index != line.line_index.wrapping_sub(1) && !overflowed { try!(write!(&mut self.dst, "{0:1$}...\n", "", skip)); } // Print offending code-line remaining_err_lines -= 1; try!(write!(&mut self.dst, "{}:{:>width$} {}\n", fm.name, line.line_index + 1, cur_line_str, width=digits)); if s.len() > skip { // Render the spans we assembled previously (if any). try!(println_maybe_styled!(&mut self.dst, term::Attr::ForegroundColor(lvl.color()), "{}", s)); } if !overflowed_buf.is_empty() { // Print code-lines trailing the rendered spans (when a span overflows) try!(write!(&mut self.dst, "{}", &overflowed_buf)); overflowed_buf.clear(); } else { prev_line_index = line.line_index; } } // If we elided something, put an ellipsis. if lines.next().is_some() { try!(write!(&mut self.dst, "{0:1$}...\n", "", skip)); } Ok(()) } /// Here are the differences between this and the normal `highlight_lines`: /// `end_highlight_lines` will always put arrow on the last byte of each /// span (instead of the first byte). Also, when a span is too long (more /// than 6 lines), `end_highlight_lines` will print the first line, then /// dot dot dot, then last line, whereas `highlight_lines` prints the first /// six lines. #[allow(deprecated)] fn end_highlight_lines(&mut self, msp: &MultiSpan, lvl: Level) -> io::Result<()> { let lines = match self.cm.span_to_lines(msp.to_span_bounds()) { Ok(lines) => lines, Err(_) => { try!(write!(&mut self.dst, "(internal compiler error: unprintable span)\n")); return Ok(()); } }; let fm = &*lines.file; if let None = fm.src { return Ok(()); } let lines = &lines.lines[..]; // Calculate the widest number to format evenly let first_line = lines.first().unwrap(); let last_line = lines.last().unwrap(); let digits = line_num_max_digits(last_line); let skip = fm.name.chars().count() + digits + 2; let mut spans = msp.spans.iter().peekable(); let mut lines = lines.iter(); let mut prev_line_index = first_line.line_index.wrapping_sub(1); // Display at most MAX_HIGHLIGHT_LINES lines. let mut remaining_err_lines = MAX_HIGHLIGHT_LINES; 'l: loop { if remaining_err_lines <= 0 { break; } let line = match lines.next() { Some(line) => line, None => break, }; // Skip is the number of characters we need to skip because they are // part of the 'filename:line ' part of the previous line. let mut s: String = ::std::iter::repeat(' ').take(skip).collect(); let line_str = fm.get_line(line.line_index).unwrap(); let mut line_chars = line_str.chars().enumerate(); let mut line_spans = 0; loop { // Peek here to preserve the span if it doesn't belong to this line let sp = match spans.peek() { Some(sp) => **sp, None => break, }; let lo = self.cm.lookup_char_pos(sp.lo); let hi = self.cm.lookup_char_pos(sp.hi); let elide_sp = (hi.line - lo.line) >= MAX_SP_LINES; let line_num = line.line_index + 1; if !(lo.line <= line_num && hi.line >= line_num) { // This line is not contained in the span if line_spans == 0 { continue 'l; } else { // This line is finished, now render the spans we've assembled break } } else if hi.line > line_num { if elide_sp && lo.line < line_num { // This line is inbetween the first and last line of the span, // so we may want to elide it. continue 'l; } else { break } } line_spans += 1; spans.next(); for (pos, ch) in line_chars.by_ref() { // Span seems to use half-opened interval, so subtract 1 if pos >= hi.col.to_usize() - 1 { break; } // Whenever a tab occurs on the previous line, we insert one on // the error-point-squiggly-line as well (instead of a space). // That way the squiggly line will usually appear in the correct // position. match ch { '\t' => s.push('\t'), _ => s.push(' '), } } s.push('^'); } if prev_line_index != line.line_index.wrapping_sub(1) { // If we elided something, put an ellipsis. try!(write!(&mut self.dst, "{0:1$}...\n", "", skip)); } // Print offending code-lines try!(write!(&mut self.dst, "{}:{:>width$} {}\n", fm.name, line.line_index + 1, line_str, width=digits)); remaining_err_lines -= 1; if s.len() > skip { // Render the spans we assembled previously (if any) try!(println_maybe_styled!(&mut self.dst, term::Attr::ForegroundColor(lvl.color()), "{}", s)); } prev_line_index = line.line_index; } Ok(()) } fn print_macro_backtrace(&mut self, sp: Span) -> io::Result<()> { let mut last_span = codemap::DUMMY_SP; let mut span = sp; loop { let span_name_span = self.cm.with_expn_info(span.expn_id, |expn_info| { expn_info.map(|ei| { let (pre, post) = match ei.callee.format { codemap::MacroAttribute(..) => ("#[", "]"), codemap::MacroBang(..) => ("", "!"), }; let macro_decl_name = format!("in this expansion of {}{}{}", pre, ei.callee.name(), post); let def_site_span = ei.callee.span; (ei.call_site, macro_decl_name, def_site_span) }) }); let (macro_decl_name, def_site_span) = match span_name_span { None => break, Some((sp, macro_decl_name, def_site_span)) => { span = sp; (macro_decl_name, def_site_span) } }; // Don't print recursive invocations if !span.source_equal(&last_span) { let mut diag_string = macro_decl_name; if let Some(def_site_span) = def_site_span { diag_string.push_str(&format!(" (defined in {})", self.cm.span_to_filename(def_site_span))); } let snippet = self.cm.span_to_string(span); try!(print_diagnostic(&mut self.dst, &snippet, Note, &diag_string, None)); } last_span = span; } Ok(()) } } fn line_num_max_digits(line: &codemap::LineInfo) -> usize { let mut max_line_num = line.line_index + 1; let mut digits = 0; while max_line_num > 0 { max_line_num /= 10; digits += 1; } digits } fn print_diagnostic(dst: &mut Destination, topic: &str, lvl: Level, msg: &str, code: Option<&str>) -> io::Result<()> { if !topic.is_empty() { try!(write!(dst, "{} ", topic)); } try!(print_maybe_styled!(dst, term::Attr::ForegroundColor(lvl.color()), "{}: ", lvl.to_string())); try!(print_maybe_styled!(dst, term::Attr::Bold, "{}", msg)); if let Some(code) = code { let style = term::Attr::ForegroundColor(term::color::BRIGHT_MAGENTA); try!(print_maybe_styled!(dst, style, " [{}]", code.clone())); } try!(write!(dst, "\n")); Ok(()) } #[cfg(unix)] fn stderr_isatty() -> bool { use libc; unsafe { libc::isatty(libc::STDERR_FILENO) != 0 } } #[cfg(windows)] fn stderr_isatty() -> bool { type DWORD = u32; type BOOL = i32; type HANDLE = *mut u8; const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD; extern "system" { fn GetStdHandle(which: DWORD) -> HANDLE; fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: *mut DWORD) -> BOOL; } unsafe { let handle = GetStdHandle(STD_ERROR_HANDLE); let mut out = 0; GetConsoleMode(handle, &mut out) != 0 } } enum Destination { Terminal(Box), Raw(Box), } impl Destination { fn from_stderr() -> Destination { match term::stderr() { Some(t) => Terminal(t), None => Raw(Box::new(io::stderr())), } } fn print_maybe_styled(&mut self, args: fmt::Arguments, color: term::Attr, print_newline_at_end: bool) -> io::Result<()> { match *self { Terminal(ref mut t) => { try!(t.attr(color)); // If `msg` ends in a newline, we need to reset the color before // the newline. We're making the assumption that we end up writing // to a `LineBufferedWriter`, which means that emitting the reset // after the newline ends up buffering the reset until we print // another line or exit. Buffering the reset is a problem if we're // sharing the terminal with any other programs (e.g. other rustc // instances via `make -jN`). // // Note that if `msg` contains any internal newlines, this will // result in the `LineBufferedWriter` flushing twice instead of // once, which still leaves the opportunity for interleaved output // to be miscolored. We assume this is rare enough that we don't // have to worry about it. try!(t.write_fmt(args)); try!(t.reset()); if print_newline_at_end { t.write_all(b"\n") } else { Ok(()) } } Raw(ref mut w) => { try!(w.write_fmt(args)); if print_newline_at_end { w.write_all(b"\n") } else { Ok(()) } } } } } impl Write for Destination { fn write(&mut self, bytes: &[u8]) -> io::Result { match *self { Terminal(ref mut t) => t.write(bytes), Raw(ref mut w) => w.write(bytes), } } fn flush(&mut self) -> io::Result<()> { match *self { Terminal(ref mut t) => t.flush(), Raw(ref mut w) => w.flush(), } } } #[cfg(test)] mod test { use errors::{Level, CodeSuggestion}; use super::EmitterWriter; use codemap::{mk_sp, CodeMap, Span, MultiSpan, BytePos, NO_EXPANSION}; use std::sync::{Arc, Mutex}; use std::io::{self, Write}; use std::str::from_utf8; use std::rc::Rc; struct Sink(Arc>>); impl Write for Sink { fn write(&mut self, data: &[u8]) -> io::Result { Write::write(&mut *self.0.lock().unwrap(), data) } fn flush(&mut self) -> io::Result<()> { Ok(()) } } /// Given a string like " ^~~~~~~~~~~~ ", produces a span /// coverting that range. The idea is that the string has the same /// length as the input, and we uncover the byte positions. Note /// that this can span lines and so on. fn span_from_selection(input: &str, selection: &str) -> Span { assert_eq!(input.len(), selection.len()); let left_index = selection.find('^').unwrap() as u32; let right_index = selection.rfind('~').map(|x|x as u32).unwrap_or(left_index); Span { lo: BytePos(left_index), hi: BytePos(right_index + 1), expn_id: NO_EXPANSION } } // Diagnostic doesn't align properly in span where line number increases by one digit #[test] 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 content = "abcdefg koksi line3 line4 cinq line6 line7 line8 line9 line10 e-lä-vän tolv dreizehn "; let file = cm.new_filemap_and_lines("dummy.txt", content); let start = file.lines.borrow()[7]; let end = file.lines.borrow()[11]; let sp = mk_sp(start, end); let lvl = Level::Error; println!("highlight_lines"); ew.highlight_lines(&sp.into(), lvl).unwrap(); println!("done"); let vec = data.lock().unwrap().clone(); let vec: &[u8] = &vec; let str = from_utf8(vec).unwrap(); println!("{}", str); assert_eq!(str, "dummy.txt: 8 line8\n\ dummy.txt: 9 line9\n\ dummy.txt:10 line10\n\ dummy.txt:11 e-lä-vän\n\ dummy.txt:12 tolv\n"); } #[test] fn test_single_span_splice() { // Test that a `MultiSpan` containing a single span splices a substition correctly let cm = CodeMap::new(); let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n"; let selection = " \n ^~\n~~~\n~~~~~ \n \n"; cm.new_filemap_and_lines("blork.rs", inputtext); let sp = span_from_selection(inputtext, selection); let msp: MultiSpan = sp.into(); // check that we are extracting the text we thought we were extracting assert_eq!(&cm.span_to_snippet(sp).unwrap(), "BB\nCCC\nDDDDD"); let substitute = "ZZZZZZ".to_owned(); let expected = "bbbbZZZZZZddddd"; let suggest = CodeSuggestion { msp: msp, substitutes: vec![substitute], }; assert_eq!(suggest.splice_lines(&cm), expected); } #[test] fn test_multiple_span_splice() { // Test that a `MultiSpan` containing multiple spans splices substitions on // several lines correctly let cm = CodeMap::new(); let inp = "aaaaabbbbBB\nZZ\nZZ\nCCCDDDDDdddddeee"; let sp1 = " ^~~~~~\n \n \n "; let sp2 = " \n \n \n^~~~~~ "; let sp3 = " \n \n \n ^~~ "; let sp4 = " \n \n \n ^~~~ "; let span_eq = |sp, eq| assert_eq!(&cm.span_to_snippet(sp).unwrap(), eq); cm.new_filemap_and_lines("blork.rs", inp); let sp1 = span_from_selection(inp, sp1); let sp2 = span_from_selection(inp, sp2); let sp3 = span_from_selection(inp, sp3); let sp4 = span_from_selection(inp, sp4); span_eq(sp1, "bbbbBB"); span_eq(sp2, "CCCDDD"); span_eq(sp3, "ddd"); span_eq(sp4, "ddee"); let substitutes: Vec = ["1", "2", "3", "4"].iter().map(|x|x.to_string()).collect(); let expected = "aaaaa1\nZZ\nZZ\n2DD34e"; let test = |msp| { let suggest = CodeSuggestion { msp: msp, substitutes: substitutes.clone(), }; let actual = suggest.splice_lines(&cm); assert_eq!(actual, expected); }; test(MultiSpan { spans: vec![sp1, sp2, sp3, sp4] }); // Test ordering and merging by `MultiSpan::push` let mut msp = MultiSpan::new(); msp.push_merge(sp2); msp.push_merge(sp1); assert_eq!(&msp.spans, &[sp1, sp2]); msp.push_merge(sp4); assert_eq!(&msp.spans, &[sp1, sp2, sp4]); msp.push_merge(sp3); assert_eq!(&msp.spans, &[sp1, sp2, sp3, sp4]); test(msp); } #[test] 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 inp = "_____aaaaaa____bbbbbb__cccccdd_"; let sp1 = " ^~~~~~ "; let sp2 = " ^~~~~~ "; let sp3 = " ^~~~~ "; let sp4 = " ^~~~ "; let sp34 = " ^~~~~~~ "; let sp4_end = " ^~ "; let expect_start = "dummy.txt:1 _____aaaaaa____bbbbbb__cccccdd_\n\ \x20 ^~~~~~ ^~~~~~ ^~~~~~~\n"; let expect_end = "dummy.txt:1 _____aaaaaa____bbbbbb__cccccdd_\n\ \x20 ^ ^ ^ ^\n"; let span = |sp, expected| { let sp = span_from_selection(inp, sp); assert_eq!(&cm.span_to_snippet(sp).unwrap(), expected); sp }; cm.new_filemap_and_lines("dummy.txt", inp); let sp1 = span(sp1, "aaaaaa"); let sp2 = span(sp2, "bbbbbb"); let sp3 = span(sp3, "ccccc"); let sp4 = span(sp4, "ccdd"); let sp34 = span(sp34, "cccccdd"); let sp4_end = span(sp4_end, "dd"); let spans = vec![sp1, sp2, sp3, sp4]; let test = |expected, highlight: &mut FnMut()| { data.lock().unwrap().clear(); highlight(); let vec = data.lock().unwrap().clone(); let actual = from_utf8(&vec[..]).unwrap(); assert_eq!(actual, expected); }; let msp = MultiSpan { spans: vec![sp1, sp2, sp34] }; let msp_end = MultiSpan { spans: vec![sp1, sp2, sp3, sp4_end] }; test(expect_start, &mut || { diag.highlight_lines(&msp, Level::Error).unwrap(); }); test(expect_end, &mut || { diag.end_highlight_lines(&msp_end, Level::Error).unwrap(); }); test(expect_start, &mut || { for msp in cm.group_spans(spans.clone()) { diag.highlight_lines(&msp, Level::Error).unwrap(); } }); test(expect_end, &mut || { for msp in cm.end_group_spans(spans.clone()) { diag.end_highlight_lines(&msp, Level::Error).unwrap(); } }); } #[test] 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 inp = "aaaaa\n\ aaaaa\n\ aaaaa\n\ bbbbb\n\ ccccc\n\ xxxxx\n\ yyyyy\n\ _____\n\ ddd__eee_\n\ elided\n\ __f_gg"; let file = cm.new_filemap_and_lines("dummy.txt", inp); let span = |lo, hi, (off_lo, off_hi)| { let lines = file.lines.borrow(); let (mut lo, mut hi): (BytePos, BytePos) = (lines[lo], lines[hi]); lo.0 += off_lo; hi.0 += off_hi; mk_sp(lo, hi) }; let sp0 = span(4, 6, (0, 5)); let sp1 = span(0, 6, (0, 5)); let sp2 = span(8, 8, (0, 3)); let sp3 = span(8, 8, (5, 8)); let sp4 = span(10, 10, (2, 3)); let sp5 = span(10, 10, (4, 6)); let expect0 = "dummy.txt: 5 ccccc\n\ dummy.txt: 6 xxxxx\n\ dummy.txt: 7 yyyyy\n\ \x20 ...\n\ dummy.txt: 9 ddd__eee_\n\ \x20 ^~~ ^~~\n\ \x20 ...\n\ dummy.txt:11 __f_gg\n\ \x20 ^ ^~\n"; let expect = "dummy.txt: 1 aaaaa\n\ dummy.txt: 2 aaaaa\n\ dummy.txt: 3 aaaaa\n\ dummy.txt: 4 bbbbb\n\ dummy.txt: 5 ccccc\n\ dummy.txt: 6 xxxxx\n\ \x20 ...\n"; let expect_g1 = "dummy.txt:1 aaaaa\n\ dummy.txt:2 aaaaa\n\ dummy.txt:3 aaaaa\n\ dummy.txt:4 bbbbb\n\ dummy.txt:5 ccccc\n\ dummy.txt:6 xxxxx\n\ \x20 ...\n"; let expect2 = "dummy.txt: 9 ddd__eee_\n\ \x20 ^~~ ^~~\n\ \x20 ...\n\ dummy.txt:11 __f_gg\n\ \x20 ^ ^~\n"; let expect_end = "dummy.txt: 1 aaaaa\n\ \x20 ...\n\ dummy.txt: 7 yyyyy\n\ \x20 ^\n\ \x20 ...\n\ dummy.txt: 9 ddd__eee_\n\ \x20 ^ ^\n\ \x20 ...\n\ dummy.txt:11 __f_gg\n\ \x20 ^ ^\n"; let expect0_end = "dummy.txt: 5 ccccc\n\ dummy.txt: 6 xxxxx\n\ dummy.txt: 7 yyyyy\n\ \x20 ^\n\ \x20 ...\n\ dummy.txt: 9 ddd__eee_\n\ \x20 ^ ^\n\ \x20 ...\n\ dummy.txt:11 __f_gg\n\ \x20 ^ ^\n"; let expect_end_g1 = "dummy.txt:1 aaaaa\n\ \x20 ...\n\ dummy.txt:7 yyyyy\n\ \x20 ^\n"; let expect2_end = "dummy.txt: 9 ddd__eee_\n\ \x20 ^ ^\n\ \x20 ...\n\ dummy.txt:11 __f_gg\n\ \x20 ^ ^\n"; let expect_groups = [expect2, expect_g1]; let expect_end_groups = [expect2_end, expect_end_g1]; let spans = vec![sp3, sp1, sp4, sp2, sp5]; macro_rules! test { ($expected: expr, $highlight: expr) => ({ data.lock().unwrap().clear(); $highlight(); let vec = data.lock().unwrap().clone(); let actual = from_utf8(&vec[..]).unwrap(); println!("actual:"); println!("{}", actual); println!("expected:"); println!("{}", $expected); assert_eq!(&actual[..], &$expected[..]); }); } let msp0 = MultiSpan { spans: vec![sp0, sp2, sp3, sp4, sp5] }; let msp = MultiSpan { spans: vec![sp1, sp2, sp3, sp4, sp5] }; let msp2 = MultiSpan { spans: vec![sp2, sp3, sp4, sp5] }; test!(expect0, || { diag.highlight_lines(&msp0, Level::Error).unwrap(); }); test!(expect0_end, || { diag.end_highlight_lines(&msp0, Level::Error).unwrap(); }); test!(expect, || { diag.highlight_lines(&msp, Level::Error).unwrap(); }); test!(expect_end, || { diag.end_highlight_lines(&msp, Level::Error).unwrap(); }); test!(expect2, || { diag.highlight_lines(&msp2, Level::Error).unwrap(); }); test!(expect2_end, || { diag.end_highlight_lines(&msp2, Level::Error).unwrap(); }); for (msp, expect) in cm.group_spans(spans.clone()).iter().zip(expect_groups.iter()) { test!(expect, || { diag.highlight_lines(&msp, Level::Error).unwrap(); }); } for (msp, expect) in cm.group_spans(spans.clone()).iter().zip(expect_end_groups.iter()) { test!(expect, || { diag.end_highlight_lines(&msp, Level::Error).unwrap(); }); } } }