src/librustc_errors/json.rs

   1 //! A JSON emitter for errors.
   2 //!
   3 //! This works by converting errors to a simplified structural format (see the
   4 //! structs at the start of the file) and then serializing them. These should
   5 //! contain as much information about the error as possible.
   6 //!
   7 //! The format of the JSON output should be considered *unstable*. For now the
   8 //! structs at the end of this file (Diagnostic*) specify the error format.
   9
  10 // FIXME: spec the JSON output properly.
  11
  12 use rustc_span::source_map::{FilePathMapping, SourceMap};
  13
  14 use crate::emitter::{Emitter, HumanReadableErrorType};
  15 use crate::registry::Registry;
  16 use crate::{Applicability, DiagnosticId};
  17 use crate::{CodeSuggestion, SubDiagnostic};
  18
  19 use rustc_data_structures::sync::Lrc;
  20 use rustc_span::hygiene::ExpnData;
  21 use rustc_span::{MultiSpan, Span, SpanLabel};
  22 use std::io::{self, Write};
  23 use std::path::Path;
  24 use std::sync::{Arc, Mutex};
  25 use std::vec;
  26
  27 use rustc_serialize::json::{as_json, as_pretty_json};
  28
  29 #[cfg(test)]
  30 mod tests;
  31
  32 pub struct JsonEmitter {
  33     dst: Box<dyn Write + Send>,
  34     registry: Option<Registry>,
  35     sm: Lrc<SourceMap>,
  36     pretty: bool,
  37     ui_testing: bool,
  38     json_rendered: HumanReadableErrorType,
  39     terminal_width: Option<usize>,
  40     macro_backtrace: bool,
  41 }
  42
  43 impl JsonEmitter {
  44     pub fn stderr(
  45         registry: Option<Registry>,
  46         source_map: Lrc<SourceMap>,
  47         pretty: bool,
  48         json_rendered: HumanReadableErrorType,
  49         terminal_width: Option<usize>,
  50         macro_backtrace: bool,
  51     ) -> JsonEmitter {
  52         JsonEmitter {
  53             dst: Box::new(io::BufWriter::new(io::stderr())),
  54             registry,
  55             sm: source_map,
  56             pretty,
  57             ui_testing: false,
  58             json_rendered,
  59             terminal_width,
  60             macro_backtrace,
  61         }
  62     }
  63
  64     pub fn basic(
  65         pretty: bool,
  66         json_rendered: HumanReadableErrorType,
  67         terminal_width: Option<usize>,
  68         macro_backtrace: bool,
  69     ) -> JsonEmitter {
  70         let file_path_mapping = FilePathMapping::empty();
  71         JsonEmitter::stderr(
  72             None,
  73             Lrc::new(SourceMap::new(file_path_mapping)),
  74             pretty,
  75             json_rendered,
  76             terminal_width,
  77             macro_backtrace,
  78         )
  79     }
  80
  81     pub fn new(
  82         dst: Box<dyn Write + Send>,
  83         registry: Option<Registry>,
  84         source_map: Lrc<SourceMap>,
  85         pretty: bool,
  86         json_rendered: HumanReadableErrorType,
  87         terminal_width: Option<usize>,
  88         macro_backtrace: bool,
  89     ) -> JsonEmitter {
  90         JsonEmitter {
  91             dst,
  92             registry,
  93             sm: source_map,
  94             pretty,
  95             ui_testing: false,
  96             json_rendered,
  97             terminal_width,
  98             macro_backtrace,
  99         }
 100     }
 101
 102     pub fn ui_testing(self, ui_testing: bool) -> Self {
 103         Self { ui_testing, ..self }
 104     }
 105 }
 106
 107 impl Emitter for JsonEmitter {
 108     fn emit_diagnostic(&mut self, diag: &crate::Diagnostic) {
 109         let data = Diagnostic::from_errors_diagnostic(diag, self);
 110         let result = if self.pretty {
 111             writeln!(&mut self.dst, "{}", as_pretty_json(&data))
 112         } else {
 113             writeln!(&mut self.dst, "{}", as_json(&data))
 114         }
 115         .and_then(|_| self.dst.flush());
 116         if let Err(e) = result {
 117             panic!("failed to print diagnostics: {:?}", e);
 118         }
 119     }
 120
 121     fn emit_artifact_notification(&mut self, path: &Path, artifact_type: &str) {
 122         let data = ArtifactNotification { artifact: path, emit: artifact_type };
 123         let result = if self.pretty {
 124             writeln!(&mut self.dst, "{}", as_pretty_json(&data))
 125         } else {
 126             writeln!(&mut self.dst, "{}", as_json(&data))
 127         }
 128         .and_then(|_| self.dst.flush());
 129         if let Err(e) = result {
 130             panic!("failed to print notification: {:?}", e);
 131         }
 132     }
 133
 134     fn source_map(&self) -> Option<&Lrc<SourceMap>> {
 135         Some(&self.sm)
 136     }
 137
 138     fn should_show_explain(&self) -> bool {
 139         match self.json_rendered {
 140             HumanReadableErrorType::Short(_) => false,
 141             _ => true,
 142         }
 143     }
 144 }
 145
 146 // The following data types are provided just for serialisation.
 147
 148 #[derive(Encodable)]
 149 struct Diagnostic {
 150     /// The primary error message.
 151     message: String,
 152     code: Option<DiagnosticCode>,
 153     /// "error: internal compiler error", "error", "warning", "note", "help".
 154     level: &'static str,
 155     spans: Vec<DiagnosticSpan>,
 156     /// Associated diagnostic messages.
 157     children: Vec<Diagnostic>,
 158     /// The message as rustc would render it.
 159     rendered: Option<String>,
 160 }
 161
 162 #[derive(Encodable)]
 163 struct DiagnosticSpan {
 164     file_name: String,
 165     byte_start: u32,
 166     byte_end: u32,
 167     /// 1-based.
 168     line_start: usize,
 169     line_end: usize,
 170     /// 1-based, character offset.
 171     column_start: usize,
 172     column_end: usize,
 173     /// Is this a "primary" span -- meaning the point, or one of the points,
 174     /// where the error occurred?
 175     is_primary: bool,
 176     /// Source text from the start of line_start to the end of line_end.
 177     text: Vec<DiagnosticSpanLine>,
 178     /// Label that should be placed at this location (if any)
 179     label: Option<String>,
 180     /// If we are suggesting a replacement, this will contain text
 181     /// that should be sliced in atop this span.
 182     suggested_replacement: Option<String>,
 183     /// If the suggestion is approximate
 184     suggestion_applicability: Option<Applicability>,
 185     /// Macro invocations that created the code at this span, if any.
 186     expansion: Option<Box<DiagnosticSpanMacroExpansion>>,
 187 }
 188
 189 #[derive(Encodable)]
 190 struct DiagnosticSpanLine {
 191     text: String,
 192
 193     /// 1-based, character offset in self.text.
 194     highlight_start: usize,
 195
 196     highlight_end: usize,
 197 }
 198
 199 #[derive(Encodable)]
 200 struct DiagnosticSpanMacroExpansion {
 201     /// span where macro was applied to generate this code; note that
 202     /// this may itself derive from a macro (if
 203     /// `span.expansion.is_some()`)
 204     span: DiagnosticSpan,
 205
 206     /// name of macro that was applied (e.g., "foo!" or "#[derive(Eq)]")
 207     macro_decl_name: String,
 208
 209     /// span where macro was defined (if known)
 210     def_site_span: DiagnosticSpan,
 211 }
 212
 213 #[derive(Encodable)]
 214 struct DiagnosticCode {
 215     /// The code itself.
 216     code: String,
 217     /// An explanation for the code.
 218     explanation: Option<&'static str>,
 219 }
 220
 221 #[derive(Encodable)]
 222 struct ArtifactNotification<'a> {
 223     /// The path of the artifact.
 224     artifact: &'a Path,
 225     /// What kind of artifact we're emitting.
 226     emit: &'a str,
 227 }
 228
 229 impl Diagnostic {
 230     fn from_errors_diagnostic(diag: &crate::Diagnostic, je: &JsonEmitter) -> Diagnostic {
 231         let sugg = diag.suggestions.iter().map(|sugg| Diagnostic {
 232             message: sugg.msg.clone(),
 233             code: None,
 234             level: "help",
 235             spans: DiagnosticSpan::from_suggestion(sugg, je),
 236             children: vec![],
 237             rendered: None,
 238         });
 239
 240         // generate regular command line output and store it in the json
 241
 242         // A threadsafe buffer for writing.
 243         #[derive(Default, Clone)]
 244         struct BufWriter(Arc<Mutex<Vec<u8>>>);
 245
 246         impl Write for BufWriter {
 247             fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 248                 self.0.lock().unwrap().write(buf)
 249             }
 250             fn flush(&mut self) -> io::Result<()> {
 251                 self.0.lock().unwrap().flush()
 252             }
 253         }
 254         let buf = BufWriter::default();
 255         let output = buf.clone();
 256         je.json_rendered
 257             .new_emitter(
 258                 Box::new(buf),
 259                 Some(je.sm.clone()),
 260                 false,
 261                 je.terminal_width,
 262                 je.macro_backtrace,
 263             )
 264             .ui_testing(je.ui_testing)
 265             .emit_diagnostic(diag);
 266         let output = Arc::try_unwrap(output.0).unwrap().into_inner().unwrap();
 267         let output = String::from_utf8(output).unwrap();
 268
 269         Diagnostic {
 270             message: diag.message(),
 271             code: DiagnosticCode::map_opt_string(diag.code.clone(), je),
 272             level: diag.level.to_str(),
 273             spans: DiagnosticSpan::from_multispan(&diag.span, je),
 274             children: diag
 275                 .children
 276                 .iter()
 277                 .map(|c| Diagnostic::from_sub_diagnostic(c, je))
 278                 .chain(sugg)
 279                 .collect(),
 280             rendered: Some(output),
 281         }
 282     }
 283
 284     fn from_sub_diagnostic(diag: &SubDiagnostic, je: &JsonEmitter) -> Diagnostic {
 285         Diagnostic {
 286             message: diag.message(),
 287             code: None,
 288             level: diag.level.to_str(),
 289             spans: diag
 290                 .render_span
 291                 .as_ref()
 292                 .map(|sp| DiagnosticSpan::from_multispan(sp, je))
 293                 .unwrap_or_else(|| DiagnosticSpan::from_multispan(&diag.span, je)),
 294             children: vec![],
 295             rendered: None,
 296         }
 297     }
 298 }
 299
 300 impl DiagnosticSpan {
 301     fn from_span_label(
 302         span: SpanLabel,
 303         suggestion: Option<(&String, Applicability)>,
 304         je: &JsonEmitter,
 305     ) -> DiagnosticSpan {
 306         Self::from_span_etc(span.span, span.is_primary, span.label, suggestion, je)
 307     }
 308
 309     fn from_span_etc(
 310         span: Span,
 311         is_primary: bool,
 312         label: Option<String>,
 313         suggestion: Option<(&String, Applicability)>,
 314         je: &JsonEmitter,
 315     ) -> DiagnosticSpan {
 316         // obtain the full backtrace from the `macro_backtrace`
 317         // helper; in some ways, it'd be better to expand the
 318         // backtrace ourselves, but the `macro_backtrace` helper makes
 319         // some decision, such as dropping some frames, and I don't
 320         // want to duplicate that logic here.
 321         let backtrace = span.macro_backtrace();
 322         DiagnosticSpan::from_span_full(span, is_primary, label, suggestion, backtrace, je)
 323     }
 324
 325     fn from_span_full(
 326         span: Span,
 327         is_primary: bool,
 328         label: Option<String>,
 329         suggestion: Option<(&String, Applicability)>,
 330         mut backtrace: impl Iterator<Item = ExpnData>,
 331         je: &JsonEmitter,
 332     ) -> DiagnosticSpan {
 333         let start = je.sm.lookup_char_pos(span.lo());
 334         let end = je.sm.lookup_char_pos(span.hi());
 335         let backtrace_step = backtrace.next().map(|bt| {
 336             let call_site = Self::from_span_full(bt.call_site, false, None, None, backtrace, je);
 337             let def_site_span =
 338                 Self::from_span_full(bt.def_site, false, None, None, vec![].into_iter(), je);
 339             Box::new(DiagnosticSpanMacroExpansion {
 340                 span: call_site,
 341                 macro_decl_name: bt.kind.descr(),
 342                 def_site_span,
 343             })
 344         });
 345
 346         DiagnosticSpan {
 347             file_name: start.file.name.to_string(),
 348             byte_start: start.file.original_relative_byte_pos(span.lo()).0,
 349             byte_end: start.file.original_relative_byte_pos(span.hi()).0,
 350             line_start: start.line,
 351             line_end: end.line,
 352             column_start: start.col.0 + 1,
 353             column_end: end.col.0 + 1,
 354             is_primary,
 355             text: DiagnosticSpanLine::from_span(span, je),
 356             suggested_replacement: suggestion.map(|x| x.0.clone()),
 357             suggestion_applicability: suggestion.map(|x| x.1),
 358             expansion: backtrace_step,
 359             label,
 360         }
 361     }
 362
 363     fn from_multispan(msp: &MultiSpan, je: &JsonEmitter) -> Vec<DiagnosticSpan> {
 364         msp.span_labels()
 365             .into_iter()
 366             .map(|span_str| Self::from_span_label(span_str, None, je))
 367             .collect()
 368     }
 369
 370     fn from_suggestion(suggestion: &CodeSuggestion, je: &JsonEmitter) -> Vec<DiagnosticSpan> {
 371         suggestion
 372             .substitutions
 373             .iter()
 374             .flat_map(|substitution| {
 375                 substitution.parts.iter().map(move |suggestion_inner| {
 376                     let span_label =
 377                         SpanLabel { span: suggestion_inner.span, is_primary: true, label: None };
 378                     DiagnosticSpan::from_span_label(
 379                         span_label,
 380                         Some((&suggestion_inner.snippet, suggestion.applicability)),
 381                         je,
 382                     )
 383                 })
 384             })
 385             .collect()
 386     }
 387 }
 388
 389 impl DiagnosticSpanLine {
 390     fn line_from_source_file(
 391         sf: &rustc_span::SourceFile,
 392         index: usize,
 393         h_start: usize,
 394         h_end: usize,
 395     ) -> DiagnosticSpanLine {
 396         DiagnosticSpanLine {
 397             text: sf.get_line(index).map_or(String::new(), |l| l.into_owned()),
 398             highlight_start: h_start,
 399             highlight_end: h_end,
 400         }
 401     }
 402
 403     /// Creates a list of DiagnosticSpanLines from span - each line with any part
 404     /// of `span` gets a DiagnosticSpanLine, with the highlight indicating the
 405     /// `span` within the line.
 406     fn from_span(span: Span, je: &JsonEmitter) -> Vec<DiagnosticSpanLine> {
 407         je.sm
 408             .span_to_lines(span)
 409             .map(|lines| {
 410                 // We can't get any lines if the source is unavailable.
 411                 if !je.sm.ensure_source_file_source_present(lines.file.clone()) {
 412                     return vec![];
 413                 }
 414
 415                 let sf = &*lines.file;
 416                 lines
 417                     .lines
 418                     .iter()
 419                     .map(|line| {
 420                         DiagnosticSpanLine::line_from_source_file(
 421                             sf,
 422                             line.line_index,
 423                             line.start_col.0 + 1,
 424                             line.end_col.0 + 1,
 425                         )
 426                     })
 427                     .collect()
 428             })
 429             .unwrap_or_else(|_| vec![])
 430     }
 431 }
 432
 433 impl DiagnosticCode {
 434     fn map_opt_string(s: Option<DiagnosticId>, je: &JsonEmitter) -> Option<DiagnosticCode> {
 435         s.map(|s| {
 436             let s = match s {
 437                 DiagnosticId::Error(s) => s,
 438                 DiagnosticId::Lint(s) => s,
 439             };
 440             let je_result =
 441                 je.registry.as_ref().map(|registry| registry.try_find_description(&s)).unwrap();
 442
 443             DiagnosticCode { code: s, explanation: je_result.unwrap_or(None) }
 444         })
 445     }
 446 }