Auto merge of #33208 - nrc:save-json, r=pnkfelix

save-analysis: dump in JSON format

cc #18582

Author: bors

mk/crates.mk

@@ -120,7 +120,7 @@ DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir
                     log syntax serialize rustc_llvm rustc_platform_intrinsics \
                     rustc_const_math rustc_const_eval rustc_incremental
 DEPS_rustc_incremental := rbml rustc serialize rustc_data_structures
-DEPS_rustc_save_analysis := rustc log syntax
+DEPS_rustc_save_analysis := rustc log syntax serialize
 DEPS_rustc_typeck := rustc syntax rustc_platform_intrinsics rustc_const_math \
                      rustc_const_eval
 

src/librustc/session/config.rs

@@ -618,7 +618,9 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
     ls: bool = (false, parse_bool,
         "list the symbols defined by a library crate"),
     save_analysis: bool = (false, parse_bool,
-        "write syntax and type analysis information in addition to normal output"),
+        "write syntax and type analysis (in JSON format) information in addition to normal output"),
+    save_analysis_csv: bool = (false, parse_bool,
+        "write syntax and type analysis (in CSV format) information in addition to normal output"),
     print_move_fragments: bool = (false, parse_bool,
         "print out move-fragment data for every fn"),
     flowgraph_print_loans: bool = (false, parse_bool,

src/librustc_driver/driver.rs

@@ -141,8 +141,7 @@ pub fn compile_input(sess: &Session,
                                                            dep_graph));
 
         // Discard MTWT tables that aren't required past lowering to HIR.
-        if !sess.opts.debugging_opts.keep_mtwt_tables &&
-           !sess.opts.debugging_opts.save_analysis {
+        if !keep_mtwt_tables(sess) {
             syntax::ext::mtwt::clear_tables();
         }
 
@@ -179,8 +178,7 @@ pub fn compile_input(sess: &Session,
              "early lint checks",
              || lint::check_ast_crate(sess, &expanded_crate));
 
-        let opt_crate = if sess.opts.debugging_opts.keep_ast ||
-                           sess.opts.debugging_opts.save_analysis {
+        let opt_crate = if keep_ast(sess) {
             Some(&expanded_crate)
         } else {
             drop(expanded_crate);
@@ -249,6 +247,18 @@ pub fn compile_input(sess: &Session,
     Ok(())
 }
 
+fn keep_mtwt_tables(sess: &Session) -> bool {
+    sess.opts.debugging_opts.keep_mtwt_tables ||
+    sess.opts.debugging_opts.save_analysis ||
+    sess.opts.debugging_opts.save_analysis_csv
+}
+
+fn keep_ast(sess: &Session) -> bool {
+    sess.opts.debugging_opts.keep_ast ||
+    sess.opts.debugging_opts.save_analysis ||
+    sess.opts.debugging_opts.save_analysis_csv
+}
+
 /// The name used for source code that doesn't originate in a file
 /// (e.g. source from stdin or a string)
 pub fn anon_src() -> String {

src/librustc_driver/lib.rs

@@ -483,15 +483,16 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
             control.after_llvm.stop = Compilation::Stop;
         }
 
-        if sess.opts.debugging_opts.save_analysis {
+        if save_analysis(sess) {
             control.after_analysis.callback = box |state| {
                 time(state.session.time_passes(), "save analysis", || {
                     save::process_crate(state.tcx.unwrap(),
                                         state.lcx.unwrap(),
                                         state.krate.unwrap(),
                                         state.analysis.unwrap(),
                                         state.crate_name.unwrap(),
-                                        state.out_dir)
+                                        state.out_dir,
+                                        save_analysis_format(state.session))
                 });
             };
             control.after_analysis.run_callback_on_error = true;
@@ -502,6 +503,21 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
     }
 }
 
+fn save_analysis(sess: &Session) -> bool {
+    sess.opts.debugging_opts.save_analysis ||
+    sess.opts.debugging_opts.save_analysis_csv
+}
+
+fn save_analysis_format(sess: &Session) -> save::Format {
+    if sess.opts.debugging_opts.save_analysis {
+        save::Format::Json
+    } else if sess.opts.debugging_opts.save_analysis_csv {
+        save::Format::Csv
+    } else {
+        unreachable!();
+    }
+}
+
 impl RustcDefaultCalls {
     pub fn list_metadata(sess: &Session, matches: &getopts::Matches, input: &Input) -> Compilation {
         let r = matches.opt_strs("Z");

src/librustc_save_analysis/Cargo.toml

@@ -12,3 +12,4 @@ crate-type = ["dylib"]
 log = { path = "../liblog" }
 rustc = { path = "../librustc" }
 syntax = { path = "../libsyntax" }
+serialize = { path = "../libserialize" }

src/librustc_save_analysis/csv_dumper.rs

@@ -19,13 +19,12 @@ use super::span_utils::SpanUtils;
 
 pub struct CsvDumper<'tcx, 'b, W: 'b> {
     output: &'b mut W,
-    dump_spans: bool,
     span: SpanUtils<'tcx>
 }
 
 impl<'a, 'b, W: Write> CsvDumper<'a, 'b, W> {
     pub fn new(writer: &'b mut W, span: SpanUtils<'a>) -> CsvDumper<'a, 'b, W> {
-        CsvDumper { output: writer, dump_spans: false, span: span }
+        CsvDumper { output: writer, span: span }
     }
 
     fn record(&mut self, kind: &str, span: Span, values: String) {
@@ -40,36 +39,23 @@ impl<'a, 'b, W: Write> CsvDumper<'a, 'b, W> {
             error!("Error writing output '{}'", info);
         }
     }
-
-    pub fn dump_span(&mut self, kind: &str, span: Span) {
-        assert!(self.dump_spans);
-        let result = format!("span,kind,{},{},text,\"{}\"\n",
-                             kind,
-                             self.span.extent_str(span),
-                             escape(self.span.snippet(span)));
-        self.record_raw(&result);
-    }
 }
 
 impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
-    fn crate_prelude(&mut self, span: Span, data: CratePreludeData) {
-        let crate_root = data.crate_root.unwrap_or("<no source>".to_owned());
-
+    fn crate_prelude(&mut self, data: CratePreludeData) {
         let values = make_values_str(&[
             ("name", &data.crate_name),
-            ("crate_root", &crate_root)
+            ("crate_root", &data.crate_root)
         ]);
 
-        self.record("crate", span, values);
+        self.record("crate", data.span, values);
 
         for c in data.external_crates {
             let num = c.num.to_string();
-            let lo_loc = self.span.sess.codemap().lookup_char_pos(span.lo);
-            let file_name = SpanUtils::make_path_string(&lo_loc.file.name);
             let values = make_values_str(&[
                 ("name", &c.name),
                 ("crate", &num),
-                ("file_name", &file_name)
+                ("file_name", &c.file_name)
             ]);
 
             self.record_raw(&format!("external_crate{}\n", values));
@@ -78,12 +64,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record_raw("end_external_crates\n");
     }
 
-    fn enum_data(&mut self, span: Span, data: EnumData) {
-        if self.dump_spans {
-            self.dump_span("enum", span);
-            return;
-        }
-
+    fn enum_data(&mut self, data: EnumData) {
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -96,12 +77,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("enum", data.span, values);
     }
 
-    fn extern_crate(&mut self, span: Span, data: ExternCrateData) {
-        if self.dump_spans {
-            self.dump_span("extern_crate", span);
-            return;
-        }
-
+    fn extern_crate(&mut self, data: ExternCrateData) {
         let id = data.id.to_string();
         let crate_num = data.crate_num.to_string();
         let scope = data.scope.to_string();
@@ -116,12 +92,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("extern_crate", data.span, values);
     }
 
-    fn impl_data(&mut self, span: Span, data: ImplData) {
-        if self.dump_spans {
-            self.dump_span("impl", span);
-            return;
-        }
-
+    fn impl_data(&mut self, data: ImplData) {
         let self_ref = data.self_ref.unwrap_or(null_def_id());
         let trait_ref = data.trait_ref.unwrap_or(null_def_id());
 
@@ -144,10 +115,6 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
     }
 
     fn inheritance(&mut self, data: InheritanceData) {
-       if self.dump_spans {
-           return;
-       }
-
        let base_id = data.base_id.index.as_usize().to_string();
        let base_crate = data.base_id.krate.to_string();
        let deriv_id = data.deriv_id.to_string();
@@ -162,12 +129,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
        self.record("inheritance", data.span, values);
     }
 
-    fn function(&mut self, span: Span, data: FunctionData) {
-        if self.dump_spans {
-            self.dump_span("function", span);
-            return;
-        }
-
+    fn function(&mut self, data: FunctionData) {
         let (decl_id, decl_crate) = match data.declaration {
             Some(id) => (id.index.as_usize().to_string(), id.krate.to_string()),
             None => (String::new(), String::new())
@@ -186,12 +148,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("function", data.span, values);
     }
 
-    fn function_ref(&mut self, span: Span, data: FunctionRefData) {
-        if self.dump_spans {
-            self.dump_span("fn_ref", span);
-            return;
-        }
-
+    fn function_ref(&mut self, data: FunctionRefData) {
         let ref_id = data.ref_id.index.as_usize().to_string();
         let ref_crate = data.ref_id.krate.to_string();
         let scope = data.scope.to_string();
@@ -205,12 +162,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("fn_ref", data.span, values);
     }
 
-    fn function_call(&mut self, span: Span, data: FunctionCallData) {
-        if self.dump_spans {
-            self.dump_span("fn_call", span);
-            return;
-        }
-
+    fn function_call(&mut self, data: FunctionCallData) {
         let ref_id = data.ref_id.index.as_usize().to_string();
         let ref_crate = data.ref_id.krate.to_string();
         let qualname = String::new();
@@ -225,12 +177,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("fn_call", data.span, values);
     }
 
-    fn method(&mut self, span: Span, data: MethodData) {
-        if self.dump_spans {
-            self.dump_span("method_decl", span);
-            return;
-        }
-
+    fn method(&mut self, data: MethodData) {
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -239,15 +186,10 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
             ("scopeid", &scope)
         ]);
 
-        self.record("method_decl", span, values);
+        self.record("method_decl", data.span, values);
     }
 
-    fn method_call(&mut self, span: Span, data: MethodCallData) {
-        if self.dump_spans {
-            self.dump_span("method_call", span);
-            return;
-        }
-
+    fn method_call(&mut self, data: MethodCallData) {
         let (dcn, dck) = match data.decl_id {
             Some(declid) => (declid.index.as_usize().to_string(), declid.krate.to_string()),
             None => (String::new(), String::new()),
@@ -269,12 +211,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("method_call", data.span, values);
     }
 
-    fn macro_data(&mut self, span: Span, data: MacroData) {
-        if self.dump_spans {
-            self.dump_span("macro", span);
-            return;
-        }
-
+    fn macro_data(&mut self, data: MacroData) {
         let values = make_values_str(&[
             ("name", &data.name),
             ("qualname", &data.qualname)
@@ -283,12 +220,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("macro", data.span, values);
     }
 
-    fn macro_use(&mut self, span: Span, data: MacroUseData) {
-        if self.dump_spans {
-            self.dump_span("macro_use", span);
-            return;
-        }
-
+    fn macro_use(&mut self, data: MacroUseData) {
         let scope = data.scope.to_string();
         let values = make_values_str(&[
             ("callee_name", &data.name),
@@ -300,10 +232,6 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
     }
 
     fn mod_data(&mut self, data: ModData) {
-        if self.dump_spans {
-            return;
-        }
-
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -316,12 +244,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("module", data.span, values);
     }
 
-    fn mod_ref(&mut self, span: Span, data: ModRefData) {
-        if self.dump_spans {
-            self.dump_span("mod_ref", span);
-            return;
-        }
-
+    fn mod_ref(&mut self, data: ModRefData) {
         let (ref_id, ref_crate) = match data.ref_id {
             Some(rid) => (rid.index.as_usize().to_string(), rid.krate.to_string()),
             None => (0.to_string(), 0.to_string())
@@ -338,12 +261,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("mod_ref", data.span, values);
     }
 
-    fn struct_data(&mut self, span: Span, data: StructData) {
-        if self.dump_spans {
-            self.dump_span("struct", span);
-            return;
-        }
-
+    fn struct_data(&mut self, data: StructData) {
         let id = data.id.to_string();
         let ctor_id = data.ctor_id.to_string();
         let scope = data.scope.to_string();
@@ -358,12 +276,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("struct", data.span, values);
     }
 
-    fn struct_variant(&mut self, span: Span, data: StructVariantData) {
-        if self.dump_spans {
-            self.dump_span("variant_struct", span);
-            return;
-        }
-
+    fn struct_variant(&mut self, data: StructVariantData) {
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -378,12 +291,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("variant_struct", data.span, values);
     }
 
-    fn trait_data(&mut self, span: Span, data: TraitData) {
-        if self.dump_spans {
-            self.dump_span("trait", span);
-            return;
-        }
-
+    fn trait_data(&mut self, data: TraitData) {
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -396,12 +304,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("trait", data.span, values);
     }
 
-    fn tuple_variant(&mut self, span: Span, data: TupleVariantData) {
-        if self.dump_spans {
-            self.dump_span("variant", span);
-            return;
-        }
-
+    fn tuple_variant(&mut self, data: TupleVariantData) {
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -416,12 +319,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("variant", data.span, values);
     }
 
-    fn type_ref(&mut self, span: Span, data: TypeRefData) {
-        if self.dump_spans {
-            self.dump_span("type_ref", span);
-            return;
-        }
-
+    fn type_ref(&mut self, data: TypeRefData) {
         let (ref_id, ref_crate) = match data.ref_id {
             Some(id) => (id.index.as_usize().to_string(), id.krate.to_string()),
             None => (0.to_string(), 0.to_string())
@@ -438,12 +336,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("type_ref", data.span, values);
     }
 
-    fn typedef(&mut self, span: Span, data: TypedefData) {
-        if self.dump_spans {
-            self.dump_span("typedef", span);
-            return;
-        }
-
+    fn typedef(&mut self, data: TypedefData) {
         let id = data.id.to_string();
         let values = make_values_str(&[
             ("id", &id),
@@ -454,12 +347,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("typedef", data.span, values);
     }
 
-    fn use_data(&mut self, span: Span, data: UseData) {
-        if self.dump_spans {
-            self.dump_span("use_alias", span);
-            return;
-        }
-
+    fn use_data(&mut self, data: UseData) {
         let mod_id = data.mod_id.unwrap_or(null_def_id());
 
         let id = data.id.to_string();
@@ -477,12 +365,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("use_alias", data.span, values);
     }
 
-    fn use_glob(&mut self, span: Span, data: UseGlobData) {
-        if self.dump_spans {
-            self.dump_span("use_glob", span);
-            return;
-        }
-
+    fn use_glob(&mut self, data: UseGlobData) {
         let names = data.names.join(", ");
 
         let id = data.id.to_string();
@@ -496,12 +379,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("use_glob", data.span, values);
     }
 
-    fn variable(&mut self, span: Span, data: VariableData) {
-        if self.dump_spans {
-            self.dump_span("variable", span);
-            return;
-        }
-
+    fn variable(&mut self, data: VariableData) {
         let id = data.id.to_string();
         let scope = data.scope.to_string();
         let values = make_values_str(&[
@@ -516,12 +394,7 @@ impl<'a, 'b, W: Write + 'b> Dump for CsvDumper<'a, 'b, W> {
         self.record("variable", data.span, values);
     }
 
-    fn variable_ref(&mut self, span: Span, data: VariableRefData) {
-        if self.dump_spans {
-            self.dump_span("var_ref", span);
-            return;
-        }
-
+    fn variable_ref(&mut self, data: VariableRefData) {
         let ref_id = data.ref_id.index.as_usize().to_string();
         let ref_crate = data.ref_id.krate.to_string();
         let scope = data.scope.to_string();

src/librustc_save_analysis/data.rs

@@ -18,16 +18,47 @@ use std::hash::Hasher;
 use rustc::hir::def_id::DefId;
 use rustc::ty;
 use syntax::ast::{CrateNum, NodeId};
-use syntax::codemap::Span;
+use syntax::codemap::{Span, CodeMap};
+
+#[derive(Debug, Clone, RustcEncodable)]
+pub struct SpanData {
+    file_name: String,
+    byte_start: u32,
+    byte_end: u32,
+    /// 1-based.
+    line_start: usize,
+    line_end: usize,
+    /// 1-based, character offset.
+    column_start: usize,
+    column_end: usize,
+}
+
+impl SpanData {
+    pub fn from_span(span: Span, cm: &CodeMap) -> SpanData {
+        let start = cm.lookup_char_pos(span.lo);
+        let end = cm.lookup_char_pos(span.hi);
+
+        SpanData {
+            file_name: start.file.name.clone(),
+            byte_start: span.lo.0,
+            byte_end: span.hi.0,
+            line_start: start.line,
+            line_end: end.line,
+            column_start: start.col.0 + 1,
+            column_end: end.col.0 + 1,
+        }
+    }
+}
 
 pub struct CrateData {
     pub name: String,
     pub number: u32,
+    pub span: Span,
 }
 
 /// Data for any entity in the Rust language. The actual data contained varies
 /// with the kind of entity being queried. See the nested structs for details.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub enum Data {
     /// Data for Enums.
     EnumData(EnumData),
@@ -79,22 +110,24 @@ pub enum Data {
 }
 
 /// Data for the prelude of a crate.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct CratePreludeData {
     pub crate_name: String,
-    pub crate_root: Option<String>,
-    pub external_crates: Vec<ExternalCrateData>
+    pub crate_root: String,
+    pub external_crates: Vec<ExternalCrateData>,
+    pub span: Span,
 }
 
 /// Data for external crates in the prelude of a crate.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct ExternalCrateData {
     pub name: String,
-    pub num: CrateNum
+    pub num: CrateNum,
+    pub file_name: String,
 }
 
 /// Data for enum declarations.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, RustcEncodable)]
 pub struct EnumData {
     pub id: NodeId,
     pub value: String,
@@ -104,7 +137,7 @@ pub struct EnumData {
 }
 
 /// Data for extern crates.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct ExternCrateData {
     pub id: NodeId,
     pub name: String,
@@ -115,15 +148,15 @@ pub struct ExternCrateData {
 }
 
 /// Data about a function call.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct FunctionCallData {
     pub span: Span,
     pub scope: NodeId,
     pub ref_id: DefId,
 }
 
 /// Data for all kinds of functions and methods.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, RustcEncodable)]
 pub struct FunctionData {
     pub id: NodeId,
     pub name: String,
@@ -134,14 +167,14 @@ pub struct FunctionData {
 }
 
 /// Data about a function call.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct FunctionRefData {
     pub span: Span,
     pub scope: NodeId,
     pub ref_id: DefId,
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct ImplData {
     pub id: NodeId,
     pub span: Span,
@@ -150,7 +183,7 @@ pub struct ImplData {
     pub self_ref: Option<DefId>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 // FIXME: this struct should not exist. However, removing it requires heavy
 // refactoring of dump_visitor.rs. See PR 31838 for more info.
 pub struct ImplData2 {
@@ -164,23 +197,23 @@ pub struct ImplData2 {
     pub self_ref: Option<TypeRefData>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct InheritanceData {
     pub span: Span,
     pub base_id: DefId,
     pub deriv_id: NodeId
 }
 
 /// Data about a macro declaration.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct MacroData {
     pub span: Span,
     pub name: String,
     pub qualname: String,
 }
 
 /// Data about a macro use.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct MacroUseData {
     pub span: Span,
     pub name: String,
@@ -193,7 +226,7 @@ pub struct MacroUseData {
 }
 
 /// Data about a method call.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct MethodCallData {
     pub span: Span,
     pub scope: NodeId,
@@ -202,7 +235,7 @@ pub struct MethodCallData {
 }
 
 /// Data for method declarations (methods with a body are treated as functions).
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, RustcEncodable)]
 pub struct MethodData {
     pub id: NodeId,
     pub qualname: String,
@@ -211,7 +244,7 @@ pub struct MethodData {
 }
 
 /// Data for modules.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct ModData {
     pub id: NodeId,
     pub name: String,
@@ -222,15 +255,15 @@ pub struct ModData {
 }
 
 /// Data for a reference to a module.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct ModRefData {
     pub span: Span,
     pub scope: NodeId,
     pub ref_id: Option<DefId>,
     pub qualname: String
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct StructData {
     pub span: Span,
     pub id: NodeId,
@@ -240,7 +273,7 @@ pub struct StructData {
     pub value: String
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct StructVariantData {
     pub span: Span,
     pub id: NodeId,
@@ -250,7 +283,7 @@ pub struct StructVariantData {
     pub scope: NodeId
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct TraitData {
     pub span: Span,
     pub id: NodeId,
@@ -259,7 +292,7 @@ pub struct TraitData {
     pub value: String
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct TupleVariantData {
     pub span: Span,
     pub id: NodeId,
@@ -271,7 +304,7 @@ pub struct TupleVariantData {
 }
 
 /// Data for a typedef.
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct TypedefData {
     pub id: NodeId,
     pub span: Span,
@@ -280,15 +313,15 @@ pub struct TypedefData {
 }
 
 /// Data for a reference to a type or trait.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, RustcEncodable)]
 pub struct TypeRefData {
     pub span: Span,
     pub scope: NodeId,
     pub ref_id: Option<DefId>,
     pub qualname: String,
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct UseData {
     pub id: NodeId,
     pub span: Span,
@@ -297,7 +330,7 @@ pub struct UseData {
     pub scope: NodeId
 }
 
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct UseGlobData {
     pub id: NodeId,
     pub span: Span,
@@ -306,7 +339,7 @@ pub struct UseGlobData {
 }
 
 /// Data for local and global variables (consts and statics).
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct VariableData {
     pub id: NodeId,
     pub name: String,
@@ -319,7 +352,7 @@ pub struct VariableData {
 
 /// Data for the use of some item (e.g., the use of a local variable, which
 /// will refer to that variables declaration (by ref_id)).
-#[derive(Debug)]
+#[derive(Debug, RustcEncodable)]
 pub struct VariableRefData {
     pub name: String,
     pub span: Span,

src/librustc_save_analysis/dump.rs

@@ -8,33 +8,31 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syntax::codemap::Span;
-
 use super::data::*;
 
 pub trait Dump {
-    fn crate_prelude(&mut self, _: Span, _: CratePreludeData) {}
-    fn enum_data(&mut self, _: Span, _: EnumData) {}
-    fn extern_crate(&mut self, _: Span, _: ExternCrateData) {}
-    fn impl_data(&mut self, _: Span, _: ImplData) {}
-    fn inheritance(&mut self, _: InheritanceData) {}
-    fn function(&mut self, _: Span, _: FunctionData) {}
-    fn function_ref(&mut self, _: Span, _: FunctionRefData) {}
-    fn function_call(&mut self, _: Span, _: FunctionCallData) {}
-    fn method(&mut self, _: Span, _: MethodData) {}
-    fn method_call(&mut self, _: Span, _: MethodCallData) {}
-    fn macro_data(&mut self, _: Span, _: MacroData) {}
-    fn macro_use(&mut self, _: Span, _: MacroUseData) {}
-    fn mod_data(&mut self, _: ModData) {}
-    fn mod_ref(&mut self, _: Span, _: ModRefData) {}
-    fn struct_data(&mut self, _: Span, _: StructData) {}
-    fn struct_variant(&mut self, _: Span, _: StructVariantData) {}
-    fn trait_data(&mut self, _: Span, _: TraitData) {}
-    fn tuple_variant(&mut self, _: Span, _: TupleVariantData) {}
-    fn type_ref(&mut self, _: Span, _: TypeRefData) {}
-    fn typedef(&mut self, _: Span, _: TypedefData) {}
-    fn use_data(&mut self, _: Span, _: UseData) {}
-    fn use_glob(&mut self, _: Span, _: UseGlobData) {}
-    fn variable(&mut self, _: Span, _: VariableData) {}
-    fn variable_ref(&mut self, _: Span, _: VariableRefData) {}
+    fn crate_prelude(&mut self, CratePreludeData) {}
+    fn enum_data(&mut self, EnumData) {}
+    fn extern_crate(&mut self, ExternCrateData) {}
+    fn impl_data(&mut self, ImplData) {}
+    fn inheritance(&mut self, InheritanceData) {}
+    fn function(&mut self, FunctionData) {}
+    fn function_ref(&mut self, FunctionRefData) {}
+    fn function_call(&mut self, FunctionCallData) {}
+    fn method(&mut self, MethodData) {}
+    fn method_call(&mut self, MethodCallData) {}
+    fn macro_data(&mut self, MacroData) {}
+    fn macro_use(&mut self, MacroUseData) {}
+    fn mod_data(&mut self, ModData) {}
+    fn mod_ref(&mut self, ModRefData) {}
+    fn struct_data(&mut self, StructData) {}
+    fn struct_variant(&mut self, StructVariantData) {}
+    fn trait_data(&mut self, TraitData) {}
+    fn tuple_variant(&mut self, TupleVariantData) {}
+    fn type_ref(&mut self, TypeRefData) {}
+    fn typedef(&mut self, TypedefData) {}
+    fn use_data(&mut self, UseData) {}
+    fn use_glob(&mut self, UseGlobData) {}
+    fn variable(&mut self, VariableData) {}
+    fn variable_ref(&mut self, VariableRefData) {}
 }

src/librustc_save_analysis/dump_visitor.rs

@@ -26,6 +26,7 @@
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
+extern crate serialize as rustc_serialize;
 
 use rustc::hir::{self, lowering};
 use rustc::hir::map::NodeItem;
@@ -45,13 +46,15 @@ use syntax::visit::{self, Visitor};
 use syntax::print::pprust::ty_to_string;
 
 mod csv_dumper;
+mod json_dumper;
 mod data;
 mod dump;
 mod dump_visitor;
 #[macro_use]
 pub mod span_utils;
 
 pub use self::csv_dumper::CsvDumper;
+pub use self::json_dumper::JsonDumper;
 pub use self::data::*;
 pub use self::dump::Dump;
 pub use self::dump_visitor::DumpVisitor;
@@ -104,9 +107,17 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
         let mut result = Vec::new();
 
         for n in self.tcx.sess.cstore.crates() {
+            let span = match self.tcx.sess.cstore.extern_crate(n) {
+                Some(ref c) => c.span,
+                None => {
+                    debug!("Skipping crate {}, no data", n);
+                    continue;
+                }
+            };
             result.push(CrateData {
                 name: (&self.tcx.sess.cstore.crate_name(n)[..]).to_owned(),
                 number: n,
+                span: span,
             });
         }
 
@@ -677,24 +688,40 @@ impl<'v> Visitor<'v> for PathCollector {
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub enum Format {
+    Csv,
+    Json,
+}
+
+impl Format {
+    fn extension(&self) -> &'static str {
+        match *self {
+            Format::Csv => ".csv",
+            Format::Json => ".json",
+        }
+    }
+}
+
 pub fn process_crate<'l, 'tcx>(tcx: &'l TyCtxt<'tcx>,
                                lcx: &'l lowering::LoweringContext<'l>,
                                krate: &ast::Crate,
                                analysis: &'l ty::CrateAnalysis<'l>,
                                cratename: &str,
-                               odir: Option<&Path>) {
+                               odir: Option<&Path>,
+                               format: Format) {
     let _ignore = tcx.dep_graph.in_ignore();
 
     assert!(analysis.glob_map.is_some());
 
     info!("Dumping crate {}", cratename);
 
     // find a path to dump our data to
-    let mut root_path = match env::var_os("DXR_RUST_TEMP_FOLDER") {
+    let mut root_path = match env::var_os("RUST_SAVE_ANALYSIS_FOLDER") {
         Some(val) => PathBuf::from(val),
         None => match odir {
-            Some(val) => val.join("dxr"),
-            None => PathBuf::from("dxr-temp"),
+            Some(val) => val.join("save-analysis"),
+            None => PathBuf::from("save-analysis-temp"),
         },
     };
 
@@ -718,22 +745,32 @@ pub fn process_crate<'l, 'tcx>(tcx: &'l TyCtxt<'tcx>,
     };
     out_name.push_str(&cratename);
     out_name.push_str(&tcx.sess.opts.cg.extra_filename);
-    out_name.push_str(".csv");
+    out_name.push_str(format.extension());
     root_path.push(&out_name);
     let mut output_file = File::create(&root_path).unwrap_or_else(|e| {
         let disp = root_path.display();
         tcx.sess.fatal(&format!("Could not open {}: {}", disp, e));
     });
     root_path.pop();
+    let output = &mut output_file;
 
     let utils: SpanUtils<'tcx> = SpanUtils::new(&tcx.sess);
     let save_ctxt = SaveContext::new(tcx, lcx);
-    let mut dumper = CsvDumper::new(&mut output_file, utils);
-    let mut visitor = DumpVisitor::new(tcx, save_ctxt, analysis, &mut dumper);
-    // FIXME: we don't write anything!
 
-    visitor.dump_crate_info(cratename, krate);
-    visit::walk_crate(&mut visitor, krate);
+    macro_rules! dump {
+        ($new_dumper: expr) => {{
+            let mut dumper = $new_dumper;
+            let mut visitor = DumpVisitor::new(tcx, save_ctxt, analysis, &mut dumper);
+
+            visitor.dump_crate_info(cratename, krate);
+            visit::walk_crate(&mut visitor, krate);
+        }}
+    }
+
+    match format {
+        Format::Csv => dump!(CsvDumper::new(output, utils)),
+        Format::Json => dump!(JsonDumper::new(output, utils.sess.codemap())),
+    }
 }
 
 // Utility functions for the module.

src/librustc_save_analysis/json_dumper.rs

@@ -3,4 +3,5 @@ all: code
 krate2: krate2.rs
 	$(RUSTC) $<
 code: foo.rs krate2
+	$(RUSTC) foo.rs -Zsave-analysis-csv
 	$(RUSTC) foo.rs -Zsave-analysis