port compiletest to use JSON output

This uncovered a lot of bugs in compiletest and also some shortcomings
of our existing JSON output. We had to add information to the JSON
output, such as suggested text and macro backtraces. We also had to fix
various bugs in the existing tests.

Joint work with jntrnr.

Author: nikomatsakis

mk/crates.mk

@@ -128,7 +128,7 @@ DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint rustc_const_eval
 
 
-TOOL_DEPS_compiletest := test getopts log
+TOOL_DEPS_compiletest := test getopts log serialize
 TOOL_DEPS_rustdoc := rustdoc
 TOOL_DEPS_rustc := rustc_driver
 TOOL_DEPS_rustbook := std rustdoc

src/compiletest/json.rs

@@ -0,0 +1,185 @@
+// 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.
+
+use errors::{Error, ErrorKind};
+use rustc_serialize::json;
+use std::str::FromStr;
+
+// These structs are a subset of the ones found in
+// `syntax::errors::json`.
+
+#[derive(RustcEncodable, RustcDecodable)]
+struct Diagnostic {
+    message: String,
+    code: Option<DiagnosticCode>,
+    level: String,
+    spans: Vec<DiagnosticSpan>,
+    children: Vec<Diagnostic>,
+    rendered: Option<String>,
+}
+
+#[derive(RustcEncodable, RustcDecodable, Clone)]
+struct DiagnosticSpan {
+    file_name: String,
+    line_start: usize,
+    line_end: usize,
+    column_start: usize,
+    column_end: usize,
+    expansion: Option<Box<DiagnosticSpanMacroExpansion>>,
+}
+
+#[derive(RustcEncodable, RustcDecodable, Clone)]
+struct DiagnosticSpanMacroExpansion {
+    /// span where macro was applied to generate this code
+    span: DiagnosticSpan,
+
+    /// name of macro that was applied (e.g., "foo!" or "#[derive(Eq)]")
+    macro_decl_name: String,
+}
+
+#[derive(RustcEncodable, RustcDecodable, Clone)]
+struct DiagnosticCode {
+    /// The code itself.
+    code: String,
+    /// An explanation for the code.
+    explanation: Option<String>,
+}
+
+pub fn parse_output(file_name: &str, output: &str) -> Vec<Error> {
+    output.lines()
+          .flat_map(|line| parse_line(file_name, line))
+          .collect()
+}
+
+fn parse_line(file_name: &str, line: &str) -> Vec<Error> {
+    // The compiler sometimes intermingles non-JSON stuff into the
+    // output.  This hack just skips over such lines. Yuck.
+    if line.chars().next() == Some('{') {
+        match json::decode::<Diagnostic>(line) {
+            Ok(diagnostic) => {
+                let mut expected_errors = vec![];
+                push_expected_errors(&mut expected_errors, &diagnostic, file_name);
+                expected_errors
+            }
+            Err(error) => {
+                println!("failed to decode compiler output as json: `{}`", error);
+                panic!("failed to decode compiler output as json");
+            }
+        }
+    } else {
+        vec![]
+    }
+}
+
+fn push_expected_errors(expected_errors: &mut Vec<Error>,
+                        diagnostic: &Diagnostic,
+                        file_name: &str) {
+    // We only consider messages pertaining to the current file.
+    let matching_spans =
+        || diagnostic.spans.iter().filter(|span| span.file_name == file_name);
+    let with_code =
+        |span: &DiagnosticSpan, text: &str| match diagnostic.code {
+            Some(ref code) =>
+                // FIXME(#33000) -- it'd be better to use a dedicated
+                // UI harness than to include the line/col number like
+                // this, but some current tests rely on it.
+                //
+                // Note: Do NOT include the filename. These can easily
+                // cause false matches where the expected message
+                // appears in the filename, and hence the message
+                // changes but the test still passes.
+                format!("{}:{}: {}:{}: {} [{}]",
+                        span.line_start, span.column_start,
+                        span.line_end, span.column_end,
+                        text, code.code.clone()),
+            None =>
+                // FIXME(#33000) -- it'd be better to use a dedicated UI harness
+                format!("{}:{}: {}:{}: {}",
+                        span.line_start, span.column_start,
+                        span.line_end, span.column_end,
+                        text),
+        };
+
+    // Convert multi-line messages into multiple expected
+    // errors. We expect to replace these with something
+    // more structured shortly anyhow.
+    let mut message_lines = diagnostic.message.lines();
+    if let Some(first_line) = message_lines.next() {
+        for span in matching_spans() {
+            let msg = with_code(span, first_line);
+            let kind = ErrorKind::from_str(&diagnostic.level).ok();
+            expected_errors.push(
+                Error {
+                    line_num: span.line_start,
+                    kind: kind,
+                    msg: msg,
+                }
+            );
+        }
+    }
+    for next_line in message_lines {
+        for span in matching_spans() {
+            expected_errors.push(
+                Error {
+                    line_num: span.line_start,
+                    kind: None,
+                    msg: with_code(span, next_line),
+                }
+            );
+        }
+    }
+
+    // If the message has a suggestion, register that.
+    if let Some(ref rendered) = diagnostic.rendered {
+        let start_line = matching_spans().map(|s| s.line_start).min().expect("\
+            every suggestion should have at least one span");
+        for (index, line) in rendered.lines().enumerate() {
+            expected_errors.push(
+                Error {
+                    line_num: start_line + index,
+                    kind: Some(ErrorKind::Suggestion),
+                    msg: line.to_string()
+                }
+            );
+        }
+    }
+
+    // Add notes for the backtrace
+    for span in matching_spans() {
+        for frame in &span.expansion {
+            push_backtrace(expected_errors,
+                           frame,
+                           file_name);
+        }
+    }
+
+    // Flatten out the children.
+    for child in &diagnostic.children {
+        push_expected_errors(expected_errors, child, file_name);
+    }
+}
+
+fn push_backtrace(expected_errors: &mut Vec<Error>,
+                  expansion: &DiagnosticSpanMacroExpansion,
+                  file_name: &str) {
+    if expansion.span.file_name == file_name {
+        expected_errors.push(
+            Error {
+                line_num: expansion.span.line_start,
+                kind: Some(ErrorKind::Note),
+                msg: format!("in this expansion of {}", expansion.macro_decl_name),
+            }
+        );
+    }
+
+    for previous_expansion in &expansion.span.expansion {
+        push_backtrace(expected_errors, previous_expansion, file_name);
+    }
+}

src/libsyntax/codemap.rs

@@ -1394,6 +1394,56 @@ impl CodeMap {
     pub fn count_lines(&self) -> usize {
         self.files.borrow().iter().fold(0, |a, f| a + f.count_lines())
     }
+
+    pub fn macro_backtrace(&self, span: Span) -> Vec<MacroBacktrace> {
+        let mut last_span = DUMMY_SP;
+        let mut span = span;
+        let mut result = vec![];
+        loop {
+            let span_name_span = self.with_expn_info(span.expn_id, |expn_info| {
+                expn_info.map(|ei| {
+                    let (pre, post) = match ei.callee.format {
+                        MacroAttribute(..) => ("#[", "]"),
+                        MacroBang(..) => ("", "!"),
+                    };
+                    let macro_decl_name = format!("{}{}{}",
+                                                  pre,
+                                                  ei.callee.name(),
+                                                  post);
+                    let def_site_span = ei.callee.span;
+                    (ei.call_site, macro_decl_name, def_site_span)
+                })
+            });
+
+            match span_name_span {
+                None => break,
+                Some((call_site, macro_decl_name, def_site_span)) => {
+                    // Don't print recursive invocations
+                    if !call_site.source_equal(&last_span) {
+                        result.push(MacroBacktrace {
+                            call_site: call_site,
+                            macro_decl_name: macro_decl_name,
+                            def_site_span: def_site_span,
+                        });
+                    }
+                    last_span = span;
+                    span = call_site;
+                }
+            }
+        }
+        result
+    }
+}
+
+pub struct MacroBacktrace {
+    /// span where macro was applied to generate this code
+    pub call_site: Span,
+
+    /// name of macro that was applied (e.g., "foo!" or "#[derive(Eq)]")
+    pub macro_decl_name: String,
+
+    /// span where macro was defined (if known)
+    pub def_site_span: Option<Span>,
 }
 
 // _____________________________________________________________________________

src/libsyntax/errors/emitter.rs

@@ -577,46 +577,17 @@ impl EmitterWriter {
     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);
-                print_diagnostic(&mut self.dst, &snippet, Note, &diag_string, None)?;
+        for trace in self.cm.macro_backtrace(sp) {
+            let mut diag_string =
+                format!("in this expansion of {}", trace.macro_decl_name);
+            if let Some(def_site_span) = trace.def_site_span {
+                diag_string.push_str(
+                    &format!(" (defined in {})",
+                        self.cm.span_to_filename(def_site_span)));
             }
-            last_span = span;
+            let snippet = self.cm.span_to_string(sp);
+            print_diagnostic(&mut self.dst, &snippet, Note, &diag_string, None)?;
         }
-
         Ok(())
     }
 }