src/libsyntax/diagnostic.rs

   1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 pub use self::Level::*;
  12 pub use self::RenderSpan::*;
  13 pub use self::ColorConfig::*;
  14 use self::Destination::*;
  15
  16 use codemap::{Pos, Span};
  17 use codemap;
  18 use diagnostics;
  19
  20 use std::cell::{RefCell, Cell};
  21 use std::fmt;
  22 use std::io;
  23 use std::iter::range;
  24 use std::string::String;
  25 use term::WriterWrapper;
  26 use term;
  27
  28 /// maximum number of lines we will print for each error; arbitrary.
  29 static MAX_LINES: uint = 6u;
  30
  31 #[derive(Clone, Copy)]
  32 pub enum RenderSpan {
  33     /// A FullSpan renders with both with an initial line for the
  34     /// message, prefixed by file:linenum, followed by a summary of
  35     /// the source code covered by the span.
  36     FullSpan(Span),
  37
  38     /// A FileLine renders with just a line for the message prefixed
  39     /// by file:linenum.
  40     FileLine(Span),
  41 }
  42
  43 impl RenderSpan {
  44     fn span(self) -> Span {
  45         match self {
  46             FullSpan(s) | FileLine(s) => s
  47         }
  48     }
  49     fn is_full_span(&self) -> bool {
  50         match self {
  51             &FullSpan(..) => true,
  52             &FileLine(..) => false,
  53         }
  54     }
  55 }
  56
  57 #[derive(Clone, Copy)]
  58 pub enum ColorConfig {
  59     Auto,
  60     Always,
  61     Never
  62 }
  63
  64 pub trait Emitter {
  65     fn emit(&mut self, cmsp: Option<(&codemap::CodeMap, Span)>,
  66             msg: &str, code: Option<&str>, lvl: Level);
  67     fn custom_emit(&mut self, cm: &codemap::CodeMap,
  68                    sp: RenderSpan, msg: &str, lvl: Level);
  69 }
  70
  71 /// This structure is used to signify that a task has panicked with a fatal error
  72 /// from the diagnostics. You can use this with the `Any` trait to figure out
  73 /// how a rustc task died (if so desired).
  74 #[derive(Copy)]
  75 pub struct FatalError;
  76
  77 /// Signifies that the compiler died with an explicit call to `.bug`
  78 /// or `.span_bug` rather than a failed assertion, etc.
  79 #[derive(Copy)]
  80 pub struct ExplicitBug;
  81
  82 /// A span-handler is like a handler but also
  83 /// accepts span information for source-location
  84 /// reporting.
  85 pub struct SpanHandler {
  86     pub handler: Handler,
  87     pub cm: codemap::CodeMap,
  88 }
  89
  90 impl SpanHandler {
  91     pub fn span_fatal(&self, sp: Span, msg: &str) -> ! {
  92         self.handler.emit(Some((&self.cm, sp)), msg, Fatal);
  93         panic!(FatalError);
  94     }
  95     pub fn span_err(&self, sp: Span, msg: &str) {
  96         self.handler.emit(Some((&self.cm, sp)), msg, Error);
  97         self.handler.bump_err_count();
  98     }
  99     pub fn span_err_with_code(&self, sp: Span, msg: &str, code: &str) {
 100         self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Error);
 101         self.handler.bump_err_count();
 102     }
 103     pub fn span_warn(&self, sp: Span, msg: &str) {
 104         self.handler.emit(Some((&self.cm, sp)), msg, Warning);
 105     }
 106     pub fn span_warn_with_code(&self, sp: Span, msg: &str, code: &str) {
 107         self.handler.emit_with_code(Some((&self.cm, sp)), msg, code, Warning);
 108     }
 109     pub fn span_note(&self, sp: Span, msg: &str) {
 110         self.handler.emit(Some((&self.cm, sp)), msg, Note);
 111     }
 112     pub fn span_end_note(&self, sp: Span, msg: &str) {
 113         self.handler.custom_emit(&self.cm, FullSpan(sp), msg, Note);
 114     }
 115     pub fn span_help(&self, sp: Span, msg: &str) {
 116         self.handler.emit(Some((&self.cm, sp)), msg, Help);
 117     }
 118     pub fn fileline_note(&self, sp: Span, msg: &str) {
 119         self.handler.custom_emit(&self.cm, FileLine(sp), msg, Note);
 120     }
 121     pub fn span_bug(&self, sp: Span, msg: &str) -> ! {
 122         self.handler.emit(Some((&self.cm, sp)), msg, Bug);
 123         panic!(ExplicitBug);
 124     }
 125     pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
 126         self.span_bug(sp, format!("unimplemented {}", msg)[]);
 127     }
 128     pub fn handler<'a>(&'a self) -> &'a Handler {
 129         &self.handler
 130     }
 131 }
 132
 133 /// A handler deals with errors; certain errors
 134 /// (fatal, bug, unimpl) may cause immediate exit,
 135 /// others log errors for later reporting.
 136 pub struct Handler {
 137     err_count: Cell<uint>,
 138     emit: RefCell<Box<Emitter + Send>>,
 139 }
 140
 141 impl Handler {
 142     pub fn fatal(&self, msg: &str) -> ! {
 143         self.emit.borrow_mut().emit(None, msg, None, Fatal);
 144         panic!(FatalError);
 145     }
 146     pub fn err(&self, msg: &str) {
 147         self.emit.borrow_mut().emit(None, msg, None, Error);
 148         self.bump_err_count();
 149     }
 150     pub fn bump_err_count(&self) {
 151         self.err_count.set(self.err_count.get() + 1u);
 152     }
 153     pub fn err_count(&self) -> uint {
 154         self.err_count.get()
 155     }
 156     pub fn has_errors(&self) -> bool {
 157         self.err_count.get()> 0u
 158     }
 159     pub fn abort_if_errors(&self) {
 160         let s;
 161         match self.err_count.get() {
 162           0u => return,
 163           1u => s = "aborting due to previous error".to_string(),
 164           _  => {
 165             s = format!("aborting due to {} previous errors",
 166                         self.err_count.get());
 167           }
 168         }
 169         self.fatal(s[]);
 170     }
 171     pub fn warn(&self, msg: &str) {
 172         self.emit.borrow_mut().emit(None, msg, None, Warning);
 173     }
 174     pub fn note(&self, msg: &str) {
 175         self.emit.borrow_mut().emit(None, msg, None, Note);
 176     }
 177     pub fn help(&self, msg: &str) {
 178         self.emit.borrow_mut().emit(None, msg, None, Help);
 179     }
 180     pub fn bug(&self, msg: &str) -> ! {
 181         self.emit.borrow_mut().emit(None, msg, None, Bug);
 182         panic!(ExplicitBug);
 183     }
 184     pub fn unimpl(&self, msg: &str) -> ! {
 185         self.bug(format!("unimplemented {}", msg)[]);
 186     }
 187     pub fn emit(&self,
 188                 cmsp: Option<(&codemap::CodeMap, Span)>,
 189                 msg: &str,
 190                 lvl: Level) {
 191         self.emit.borrow_mut().emit(cmsp, msg, None, lvl);
 192     }
 193     pub fn emit_with_code(&self,
 194                           cmsp: Option<(&codemap::CodeMap, Span)>,
 195                           msg: &str,
 196                           code: &str,
 197                           lvl: Level) {
 198         self.emit.borrow_mut().emit(cmsp, msg, Some(code), lvl);
 199     }
 200     pub fn custom_emit(&self, cm: &codemap::CodeMap,
 201                        sp: RenderSpan, msg: &str, lvl: Level) {
 202         self.emit.borrow_mut().custom_emit(cm, sp, msg, lvl);
 203     }
 204 }
 205
 206 pub fn mk_span_handler(handler: Handler, cm: codemap::CodeMap) -> SpanHandler {
 207     SpanHandler {
 208         handler: handler,
 209         cm: cm,
 210     }
 211 }
 212
 213 pub fn default_handler(color_config: ColorConfig,
 214                        registry: Option<diagnostics::registry::Registry>) -> Handler {
 215     mk_handler(box EmitterWriter::stderr(color_config, registry))
 216 }
 217
 218 pub fn mk_handler(e: Box<Emitter + Send>) -> Handler {
 219     Handler {
 220         err_count: Cell::new(0),
 221         emit: RefCell::new(e),
 222     }
 223 }
 224
 225 #[derive(Copy, PartialEq, Clone)]
 226 pub enum Level {
 227     Bug,
 228     Fatal,
 229     Error,
 230     Warning,
 231     Note,
 232     Help,
 233 }
 234
 235 impl fmt::Show for Level {
 236     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 237         use std::fmt::Show;
 238
 239         match *self {
 240             Bug => "error: internal compiler error".fmt(f),
 241             Fatal | Error => "error".fmt(f),
 242             Warning => "warning".fmt(f),
 243             Note => "note".fmt(f),
 244             Help => "help".fmt(f),
 245         }
 246     }
 247 }
 248
 249 impl Level {
 250     fn color(self) -> term::color::Color {
 251         match self {
 252             Bug | Fatal | Error => term::color::BRIGHT_RED,
 253             Warning => term::color::BRIGHT_YELLOW,
 254             Note => term::color::BRIGHT_GREEN,
 255             Help => term::color::BRIGHT_CYAN,
 256         }
 257     }
 258 }
 259
 260 fn print_maybe_styled(w: &mut EmitterWriter,
 261                       msg: &str,
 262                       color: term::attr::Attr) -> io::IoResult<()> {
 263     match w.dst {
 264         Terminal(ref mut t) => {
 265             try!(t.attr(color));
 266             // If `msg` ends in a newline, we need to reset the color before
 267             // the newline. We're making the assumption that we end up writing
 268             // to a `LineBufferedWriter`, which means that emitting the reset
 269             // after the newline ends up buffering the reset until we print
 270             // another line or exit. Buffering the reset is a problem if we're
 271             // sharing the terminal with any other programs (e.g. other rustc
 272             // instances via `make -jN`).
 273             //
 274             // Note that if `msg` contains any internal newlines, this will
 275             // result in the `LineBufferedWriter` flushing twice instead of
 276             // once, which still leaves the opportunity for interleaved output
 277             // to be miscolored. We assume this is rare enough that we don't
 278             // have to worry about it.
 279             if msg.ends_with("\n") {
 280                 try!(t.write_str(msg[0..msg.len()-1]));
 281                 try!(t.reset());
 282                 try!(t.write_str("\n"));
 283             } else {
 284                 try!(t.write_str(msg));
 285                 try!(t.reset());
 286             }
 287             Ok(())
 288         }
 289         Raw(ref mut w) => {
 290             w.write_str(msg)
 291         }
 292     }
 293 }
 294
 295 fn print_diagnostic(dst: &mut EmitterWriter, topic: &str, lvl: Level,
 296                     msg: &str, code: Option<&str>) -> io::IoResult<()> {
 297     if !topic.is_empty() {
 298         try!(write!(&mut dst.dst, "{} ", topic));
 299     }
 300
 301     try!(print_maybe_styled(dst,
 302                             format!("{}: ", lvl.to_string())[],
 303                             term::attr::ForegroundColor(lvl.color())));
 304     try!(print_maybe_styled(dst,
 305                             format!("{}", msg)[],
 306                             term::attr::Bold));
 307
 308     match code {
 309         Some(code) => {
 310             let style = term::attr::ForegroundColor(term::color::BRIGHT_MAGENTA);
 311             try!(print_maybe_styled(dst, format!(" [{}]", code.clone())[], style));
 312         }
 313         None => ()
 314     }
 315     try!(dst.dst.write_char('\n'));
 316     Ok(())
 317 }
 318
 319 pub struct EmitterWriter {
 320     dst: Destination,
 321     registry: Option<diagnostics::registry::Registry>
 322 }
 323
 324 enum Destination {
 325     Terminal(Box<term::Terminal<WriterWrapper> + Send>),
 326     Raw(Box<Writer + Send>),
 327 }
 328
 329 impl EmitterWriter {
 330     pub fn stderr(color_config: ColorConfig,
 331                   registry: Option<diagnostics::registry::Registry>) -> EmitterWriter {
 332         let stderr = io::stderr();
 333
 334         let use_color = match color_config {
 335             Always => true,
 336             Never  => false,
 337             Auto   => stderr.get_ref().isatty()
 338         };
 339
 340         if use_color {
 341             let dst = match term::stderr() {
 342                 Some(t) => Terminal(t),
 343                 None    => Raw(box stderr),
 344             };
 345             EmitterWriter { dst: dst, registry: registry }
 346         } else {
 347             EmitterWriter { dst: Raw(box stderr), registry: registry }
 348         }
 349     }
 350
 351     pub fn new(dst: Box<Writer + Send>,
 352                registry: Option<diagnostics::registry::Registry>) -> EmitterWriter {
 353         EmitterWriter { dst: Raw(dst), registry: registry }
 354     }
 355 }
 356
 357 impl Writer for Destination {
 358     fn write(&mut self, bytes: &[u8]) -> io::IoResult<()> {
 359         match *self {
 360             Terminal(ref mut t) => t.write(bytes),
 361             Raw(ref mut w) => w.write(bytes),
 362         }
 363     }
 364 }
 365
 366 impl Emitter for EmitterWriter {
 367     fn emit(&mut self,
 368             cmsp: Option<(&codemap::CodeMap, Span)>,
 369             msg: &str, code: Option<&str>, lvl: Level) {
 370         let error = match cmsp {
 371             Some((cm, sp)) => emit(self, cm, FullSpan(sp), msg, code, lvl, false),
 372             None => print_diagnostic(self, "", lvl, msg, code),
 373         };
 374
 375         match error {
 376             Ok(()) => {}
 377             Err(e) => panic!("failed to print diagnostics: {}", e),
 378         }
 379     }
 380
 381     fn custom_emit(&mut self, cm: &codemap::CodeMap,
 382                    sp: RenderSpan, msg: &str, lvl: Level) {
 383         match emit(self, cm, sp, msg, None, lvl, true) {
 384             Ok(()) => {}
 385             Err(e) => panic!("failed to print diagnostics: {}", e),
 386         }
 387     }
 388 }
 389
 390 fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan,
 391         msg: &str, code: Option<&str>, lvl: Level, custom: bool) -> io::IoResult<()> {
 392     let sp = rsp.span();
 393     let ss = cm.span_to_string(sp);
 394     let lines = cm.span_to_lines(sp);
 395     if custom {
 396         // we want to tell compiletest/runtest to look at the last line of the
 397         // span (since `custom_highlight_lines` displays an arrow to the end of
 398         // the span)
 399         let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id};
 400         let ses = cm.span_to_string(span_end);
 401         try!(print_diagnostic(dst, ses[], lvl, msg, code));
 402         if rsp.is_full_span() {
 403             try!(custom_highlight_lines(dst, cm, sp, lvl, lines));
 404         }
 405     } else {
 406         try!(print_diagnostic(dst, ss[], lvl, msg, code));
 407         if rsp.is_full_span() {
 408             try!(highlight_lines(dst, cm, sp, lvl, lines));
 409         }
 410     }
 411     try!(print_macro_backtrace(dst, cm, sp));
 412     match code {
 413         Some(code) =>
 414             match dst.registry.as_ref().and_then(|registry| registry.find_description(code)) {
 415                 Some(_) => {
 416                     try!(print_diagnostic(dst, ss[], Help,
 417                                           format!("pass `--explain {}` to see a detailed \
 418                                                    explanation", code)[], None));
 419                 }
 420                 None => ()
 421             },
 422         None => (),
 423     }
 424     Ok(())
 425 }
 426
 427 fn highlight_lines(err: &mut EmitterWriter,
 428                    cm: &codemap::CodeMap,
 429                    sp: Span,
 430                    lvl: Level,
 431                    lines: codemap::FileLines) -> io::IoResult<()> {
 432     let fm = &*lines.file;
 433
 434     let mut elided = false;
 435     let mut display_lines = lines.lines[];
 436     if display_lines.len() > MAX_LINES {
 437         display_lines = display_lines[0u..MAX_LINES];
 438         elided = true;
 439     }
 440     // Print the offending lines
 441     for &line_number in display_lines.iter() {
 442         if let Some(line) = fm.get_line(line_number) {
 443             try!(write!(&mut err.dst, "{}:{} {}\n", fm.name,
 444                         line_number + 1, line));
 445         }
 446     }
 447     if elided {
 448         let last_line = display_lines[display_lines.len() - 1u];
 449         let s = format!("{}:{} ", fm.name, last_line + 1u);
 450         try!(write!(&mut err.dst, "{0:1$}...\n", "", s.len()));
 451     }
 452
 453     // FIXME (#3260)
 454     // If there's one line at fault we can easily point to the problem
 455     if lines.lines.len() == 1u {
 456         let lo = cm.lookup_char_pos(sp.lo);
 457         let mut digits = 0u;
 458         let mut num = (lines.lines[0] + 1u) / 10u;
 459
 460         // how many digits must be indent past?
 461         while num > 0u { num /= 10u; digits += 1u; }
 462
 463         // indent past |name:## | and the 0-offset column location
 464         let left = fm.name.len() + digits + lo.col.to_uint() + 3u;
 465         let mut s = String::new();
 466         // Skip is the number of characters we need to skip because they are
 467         // part of the 'filename:line ' part of the previous line.
 468         let skip = fm.name.len() + digits + 3u;
 469         for _ in range(0, skip) {
 470             s.push(' ');
 471         }
 472         if let Some(orig) = fm.get_line(lines.lines[0]) {
 473             for pos in range(0u, left - skip) {
 474                 let cur_char = orig.as_bytes()[pos] as char;
 475                 // Whenever a tab occurs on the previous line, we insert one on
 476                 // the error-point-squiggly-line as well (instead of a space).
 477                 // That way the squiggly line will usually appear in the correct
 478                 // position.
 479                 match cur_char {
 480                     '\t' => s.push('\t'),
 481                     _ => s.push(' '),
 482                 };
 483             }
 484         }
 485
 486         try!(write!(&mut err.dst, "{}", s));
 487         let mut s = String::from_str("^");
 488         let hi = cm.lookup_char_pos(sp.hi);
 489         if hi.col != lo.col {
 490             // the ^ already takes up one space
 491             let num_squigglies = hi.col.to_uint() - lo.col.to_uint() - 1u;
 492             for _ in range(0, num_squigglies) {
 493                 s.push('~');
 494             }
 495         }
 496         try!(print_maybe_styled(err,
 497                                 format!("{}\n", s)[],
 498                                 term::attr::ForegroundColor(lvl.color())));
 499     }
 500     Ok(())
 501 }
 502
 503 /// Here are the differences between this and the normal `highlight_lines`:
 504 /// `custom_highlight_lines` will always put arrow on the last byte of the
 505 /// span (instead of the first byte). Also, when the span is too long (more
 506 /// than 6 lines), `custom_highlight_lines` will print the first line, then
 507 /// dot dot dot, then last line, whereas `highlight_lines` prints the first
 508 /// six lines.
 509 fn custom_highlight_lines(w: &mut EmitterWriter,
 510                           cm: &codemap::CodeMap,
 511                           sp: Span,
 512                           lvl: Level,
 513                           lines: codemap::FileLines)
 514                           -> io::IoResult<()> {
 515     let fm = &*lines.file;
 516
 517     let lines = lines.lines[];
 518     if lines.len() > MAX_LINES {
 519         if let Some(line) = fm.get_line(lines[0]) {
 520             try!(write!(&mut w.dst, "{}:{} {}\n", fm.name,
 521                         lines[0] + 1, line));
 522         }
 523         try!(write!(&mut w.dst, "...\n"));
 524         let last_line_number = lines[lines.len() - 1];
 525         if let Some(last_line) = fm.get_line(last_line_number) {
 526             try!(write!(&mut w.dst, "{}:{} {}\n", fm.name,
 527                         last_line_number + 1, last_line));
 528         }
 529     } else {
 530         for &line_number in lines.iter() {
 531             if let Some(line) = fm.get_line(line_number) {
 532                 try!(write!(&mut w.dst, "{}:{} {}\n", fm.name,
 533                             line_number + 1, line));
 534             }
 535         }
 536     }
 537     let last_line_start = format!("{}:{} ", fm.name, lines[lines.len()-1]+1);
 538     let hi = cm.lookup_char_pos(sp.hi);
 539     // Span seems to use half-opened interval, so subtract 1
 540     let skip = last_line_start.len() + hi.col.to_uint() - 1;
 541     let mut s = String::new();
 542     for _ in range(0, skip) {
 543         s.push(' ');
 544     }
 545     s.push('^');
 546     s.push('\n');
 547     print_maybe_styled(w,
 548                        s[],
 549                        term::attr::ForegroundColor(lvl.color()))
 550 }
 551
 552 fn print_macro_backtrace(w: &mut EmitterWriter,
 553                          cm: &codemap::CodeMap,
 554                          sp: Span)
 555                          -> io::IoResult<()> {
 556     let cs = try!(cm.with_expn_info(sp.expn_id, |expn_info| match expn_info {
 557         Some(ei) => {
 558             let ss = ei.callee.span.map_or(String::new(), |span| cm.span_to_string(span));
 559             let (pre, post) = match ei.callee.format {
 560                 codemap::MacroAttribute => ("#[", "]"),
 561                 codemap::MacroBang => ("", "!")
 562             };
 563             try!(print_diagnostic(w, ss[], Note,
 564                                   format!("in expansion of {}{}{}", pre,
 565                                           ei.callee.name,
 566                                           post)[], None));
 567             let ss = cm.span_to_string(ei.call_site);
 568             try!(print_diagnostic(w, ss[], Note, "expansion site", None));
 569             Ok(Some(ei.call_site))
 570         }
 571         None => Ok(None)
 572     }));
 573     cs.map_or(Ok(()), |call_site| print_macro_backtrace(w, cm, call_site))
 574 }
 575
 576 pub fn expect<T, M>(diag: &SpanHandler, opt: Option<T>, msg: M) -> T where
 577     M: FnOnce() -> String,
 578 {
 579     match opt {
 580         Some(t) => t,
 581         None => diag.handler().bug(msg()[]),
 582     }
 583 }