save-analysis: remove dump spans stuff

diff --git a/src/librustc_save_analysis/csv_dumper.rs b/src/librustc_save_analysis/csv_dumper.rs
index 45ec9a97a11844308d27cc0a05eeaefcec7dd8d4..69de5365c1409a088390dc6b2dcd6180e46fc1f7 100644 (file)
--- a/src/librustc_save_analysis/csv_dumper.rs
+++ b/src/librustc_save_analysis/csv_dumper.rs
@@ -19,13 +19,12 @@
 
 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,15 +39,6 @@ fn record_raw(&mut self, info: &str) {
             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> {
@@ -78,12 +68,7 @@ fn crate_prelude(&mut self, span: Span, data: CratePreludeData) {
         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 +81,7 @@ fn enum_data(&mut self, span: Span, data: EnumData) {
         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 +96,7 @@ fn extern_crate(&mut self, span: Span, data: ExternCrateData) {
         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 +119,6 @@ fn impl_data(&mut self, span: Span, data: ImplData) {
     }
 
     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 +133,7 @@ fn inheritance(&mut self, data: InheritanceData) {
        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 +152,7 @@ fn function(&mut self, span: Span, data: FunctionData) {
         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 +166,7 @@ fn function_ref(&mut self, span: Span, data: FunctionRefData) {
         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 +181,7 @@ fn function_call(&mut self, span: Span, data: FunctionCallData) {
         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 +190,10 @@ fn method(&mut self, span: Span, data: MethodData) {
             ("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 +215,7 @@ fn method_call(&mut self, span: Span, data: MethodCallData) {
         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 +224,7 @@ fn macro_data(&mut self, span: Span, data: MacroData) {
         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 +236,6 @@ fn macro_use(&mut self, span: Span, data: MacroUseData) {
     }
 
     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 +248,7 @@ fn mod_data(&mut self, data: ModData) {
         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 +265,7 @@ fn mod_ref(&mut self, span: Span, data: ModRefData) {
         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 +280,7 @@ fn struct_data(&mut self, span: Span, data: StructData) {
         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 +295,7 @@ fn struct_variant(&mut self, span: Span, data: StructVariantData) {
         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 +308,7 @@ fn trait_data(&mut self, span: Span, data: TraitData) {
         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 +323,7 @@ fn tuple_variant(&mut self, span: Span, data: TupleVariantData) {
         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 +340,7 @@ fn type_ref(&mut self, span: Span, data: TypeRefData) {
         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 +351,7 @@ fn typedef(&mut self, span: Span, data: TypedefData) {
         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 +369,7 @@ fn use_data(&mut self, span: Span, data: UseData) {
         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 +383,7 @@ fn use_glob(&mut self, span: Span, data: UseGlobData) {
         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 +398,7 @@ fn variable(&mut self, span: Span, data: VariableData) {
         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();

diff --git a/src/librustc_save_analysis/dump.rs b/src/librustc_save_analysis/dump.rs
index b0cc7926f4e3491331053c2824ab9575c8f11f3a..69efa74c582f321a0b071dd04df86b7dce1b5513 100644 (file)
--- a/src/librustc_save_analysis/dump.rs
+++ b/src/librustc_save_analysis/dump.rs
@@ -14,27 +14,27 @@
 
 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 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) {}
 }

diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
index 4ba66c18e6eba26cab05ba88d61c1ec2544786f7..c6513a8288b0b568c802ad61f07db0556170f16a 100644 (file)
--- a/src/librustc_save_analysis/dump_visitor.rs
+++ b/src/librustc_save_analysis/dump_visitor.rs
@@ -197,7 +197,7 @@ fn write_sub_paths(&mut self, path: &ast::Path, global: bool) {
             } else {
                 qualname.clone()
             };
-            self.dumper.mod_ref(path.span, ModRefData {
+            self.dumper.mod_ref(ModRefData {
                 span: *span,
                 qualname: qualname,
                 scope: self.cur_scope,
@@ -222,7 +222,7 @@ fn write_sub_paths_truncated(&mut self, path: &ast::Path, global: bool) {
             } else {
                 qualname.clone()
             };
-            self.dumper.mod_ref(path.span, ModRefData {
+            self.dumper.mod_ref(ModRefData {
                 span: *span,
                 qualname: qualname,
                 scope: self.cur_scope,
@@ -243,7 +243,7 @@ fn write_sub_path_trait_truncated(&mut self, path: &ast::Path) {
 
         // write the trait part of the sub-path
         let (ref span, ref qualname) = sub_paths[len-2];
-        self.dumper.type_ref(path.span, TypeRefData {
+        self.dumper.type_ref(TypeRefData {
             ref_id: None,
             span: *span,
             qualname: qualname.to_owned(),
@@ -256,7 +256,7 @@ fn write_sub_path_trait_truncated(&mut self, path: &ast::Path) {
         }
         let sub_paths = &sub_paths[..len-2];
         for &(ref span, ref qualname) in sub_paths {
-            self.dumper.mod_ref(path.span, ModRefData {
+            self.dumper.mod_ref(ModRefData {
                 span: *span,
                 qualname: qualname.to_owned(),
                 scope: self.cur_scope,
@@ -298,7 +298,7 @@ fn process_def_kind(&mut self,
         match def {
             Def::Mod(_) |
             Def::ForeignMod(_) => {
-                self.dumper.mod_ref(span, ModRefData {
+                self.dumper.mod_ref(ModRefData {
                     span: sub_span.expect("No span found for mod ref"),
                     ref_id: Some(def_id),
                     scope: scope,
@@ -310,7 +310,7 @@ fn process_def_kind(&mut self,
             Def::TyAlias(..) |
             Def::AssociatedTy(..) |
             Def::Trait(_) => {
-                self.dumper.type_ref(span, TypeRefData {
+                self.dumper.type_ref(TypeRefData {
                     span: sub_span.expect("No span found for type ref"),
                     ref_id: Some(def_id),
                     scope: scope,
@@ -323,7 +323,7 @@ fn process_def_kind(&mut self,
             Def::Local(..) |
             Def::Variant(..) |
             Def::Upvar(..) => {
-                self.dumper.variable_ref(span, VariableRefData {
+                self.dumper.variable_ref(VariableRefData {
                     span: sub_span.expect("No span found for var ref"),
                     ref_id: def_id,
                     scope: scope,
@@ -331,7 +331,7 @@ fn process_def_kind(&mut self,
                 }.normalize(&self.tcx));
             }
             Def::Fn(..) => {
-                self.dumper.function_ref(span, FunctionRefData {
+                self.dumper.function_ref(FunctionRefData {
                     span: sub_span.expect("No span found for fn ref"),
                     ref_id: def_id,
                     scope: scope
@@ -362,7 +362,7 @@ fn process_formals(&mut self, formals: &Vec<ast::Arg>, qualname: &str) {
                 // variable name, but who knows?)
                 let sub_span = span_utils.span_for_last_ident(p.span);
                 if !self.span.filter_generated(sub_span, p.span) {
-                    self.dumper.variable(p.span, VariableData {
+                    self.dumper.variable(VariableData {
                         id: id,
                         span: sub_span.expect("No span found for variable"),
                         name: path_to_string(p),
@@ -388,12 +388,12 @@ fn process_method(&mut self,
 
             if body.is_some() {
                 if !self.span.filter_generated(Some(method_data.span), span) {
-                    self.dumper.function(span, method_data.clone().normalize(&self.tcx));
+                    self.dumper.function(method_data.clone().normalize(&self.tcx));
                 }
                 self.process_formals(&sig.decl.inputs, &method_data.qualname);
             } else {
                 if !self.span.filter_generated(Some(method_data.span), span) {
-                    self.dumper.method(span, MethodData {
+                    self.dumper.method(MethodData {
                         id: method_data.id,
                         span: method_data.span,
                         scope: method_data.scope,
@@ -423,7 +423,7 @@ fn process_trait_ref(&mut self, trait_ref: &ast::TraitRef) {
         let trait_ref_data = self.save_ctxt.get_trait_ref_data(trait_ref, self.cur_scope);
         if let Some(trait_ref_data) = trait_ref_data {
             if !self.span.filter_generated(Some(trait_ref_data.span), trait_ref.path.span) {
-                self.dumper.type_ref(trait_ref.path.span, trait_ref_data.normalize(&self.tcx));
+                self.dumper.type_ref(trait_ref_data.normalize(&self.tcx));
             }
 
             visit::walk_path(self, &trait_ref.path);
@@ -436,7 +436,7 @@ fn process_struct_field_def(&mut self, field: &ast::StructField, parent_id: Node
             if !self.span.filter_generated(Some(field_data.span), field.span) {
                 field_data.scope = normalize_node_id(&self.tcx, field_data.scope) as u32;
                 field_data.value = String::new();
-                self.dumper.variable(field.span, field_data.normalize(&self.tcx));
+                self.dumper.variable(field_data.normalize(&self.tcx));
             }
         }
     }
@@ -460,7 +460,7 @@ fn process_generic_params(&mut self,
                                escape(self.span.snippet(param_ss)),
                                id);
             if !self.span.filter_generated(Some(param_ss), full_span) {
-                self.dumper.typedef(full_span, TypedefData {
+                self.dumper.typedef(TypedefData {
                     span: param_ss,
                     id: param.id,
                     qualname: name,
@@ -479,7 +479,7 @@ fn process_fn(&mut self,
         if let Some(fn_data) = self.save_ctxt.get_item_data(item) {
             down_cast_data!(fn_data, FunctionData, item.span);
             if !self.span.filter_generated(Some(fn_data.span), item.span) {
-                self.dumper.function(item.span, fn_data.clone().normalize(&self.tcx));
+                self.dumper.function(fn_data.clone().normalize(&self.tcx));
             }
 
             self.process_formals(&decl.inputs, &fn_data.qualname);
@@ -503,7 +503,7 @@ fn process_static_or_const_item(&mut self, item: &ast::Item, typ: &ast::Ty, expr
             if !self.span.filter_generated(Some(var_data.span), item.span) {
                 let mut var_data = var_data;
                 var_data.scope = normalize_node_id(&self.tcx, var_data.scope) as u32;
-                self.dumper.variable(item.span, var_data.normalize(&self.tcx));
+                self.dumper.variable(var_data.normalize(&self.tcx));
             }
         }
         self.visit_ty(&typ);
@@ -521,7 +521,7 @@ fn process_const(&mut self,
         let sub_span = self.span.sub_span_after_keyword(span, keywords::Const);
 
         if !self.span.filter_generated(sub_span, span) {
-            self.dumper.variable(span, VariableData {
+            self.dumper.variable(VariableData {
                 span: sub_span.expect("No span found for variable"),
                 id: id,
                 name: name.to_string(),
@@ -546,7 +546,7 @@ fn process_struct(&mut self,
         let val = self.span.snippet(item.span);
         let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Struct);
         if !self.span.filter_generated(sub_span, item.span) {
-            self.dumper.struct_data(item.span, StructData {
+            self.dumper.struct_data(StructData {
                 span: sub_span.expect("No span found for struct"),
                 id: item.id,
                 ctor_id: def.id(),
@@ -578,7 +578,7 @@ fn process_enum(&mut self,
         down_cast_data!(enum_data, EnumData, item.span);
         let normalized = enum_data.clone().normalize(&self.tcx);
         if !self.span.filter_generated(Some(normalized.span), item.span) {
-            self.dumper.enum_data(item.span, normalized);
+            self.dumper.enum_data(normalized);
         }
 
         for variant in &enum_definition.variants {
@@ -592,7 +592,7 @@ fn process_enum(&mut self,
                 ast::VariantData::Struct(..) => {
                     let sub_span = self.span.span_for_first_ident(variant.span);
                     if !self.span.filter_generated(sub_span, variant.span) {
-                        self.dumper.struct_variant(variant.span, StructVariantData {
+                        self.dumper.struct_variant(StructVariantData {
                             span: sub_span.expect("No span found for struct variant"),
                             id: variant.node.data.id(),
                             qualname: qualname,
@@ -605,7 +605,7 @@ fn process_enum(&mut self,
                 _ => {
                     let sub_span = self.span.span_for_first_ident(variant.span);
                     if !self.span.filter_generated(sub_span, variant.span) {
-                        self.dumper.tuple_variant(variant.span, TupleVariantData {
+                        self.dumper.tuple_variant(TupleVariantData {
                             span: sub_span.expect("No span found for tuple variant"),
                             id: variant.node.data.id(),
                             name: name.to_string(),
@@ -639,19 +639,19 @@ fn process_impl(&mut self,
             if let Some(ref self_ref) = impl_data.self_ref {
                 has_self_ref = true;
                 if !self.span.filter_generated(Some(self_ref.span), item.span) {
-                    self.dumper.type_ref(item.span, self_ref.clone().normalize(&self.tcx));
+                    self.dumper.type_ref(self_ref.clone().normalize(&self.tcx));
                 }
             }
             if let Some(ref trait_ref_data) = impl_data.trait_ref {
                 if !self.span.filter_generated(Some(trait_ref_data.span), item.span) {
-                    self.dumper.type_ref(item.span, trait_ref_data.clone().normalize(&self.tcx));
+                    self.dumper.type_ref(trait_ref_data.clone().normalize(&self.tcx));
                 }
 
                 visit::walk_path(self, &trait_ref.as_ref().unwrap().path);
             }
 
             if !self.span.filter_generated(Some(impl_data.span), item.span) {
-                self.dumper.impl_data(item.span, ImplData {
+                self.dumper.impl_data(ImplData {
                     id: impl_data.id,
                     span: impl_data.span,
                     scope: impl_data.scope,
@@ -678,7 +678,7 @@ fn process_trait(&mut self,
         let val = self.span.snippet(item.span);
         let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Trait);
         if !self.span.filter_generated(sub_span, item.span) {
-            self.dumper.trait_data(item.span, TraitData {
+            self.dumper.trait_data(TraitData {
                 span: sub_span.expect("No span found for trait"),
                 id: item.id,
                 qualname: qualname.clone(),
@@ -702,7 +702,7 @@ fn process_trait(&mut self,
             if let Some(id) = self.lookup_type_ref(trait_ref.ref_id) {
                 let sub_span = self.span.sub_span_for_type_name(trait_ref.path.span);
                 if !self.span.filter_generated(sub_span, trait_ref.path.span) {
-                    self.dumper.type_ref(trait_ref.path.span, TypeRefData {
+                    self.dumper.type_ref(TypeRefData {
                         span: sub_span.expect("No span found for trait ref"),
                         ref_id: Some(id),
                         scope: self.cur_scope,
@@ -759,7 +759,7 @@ fn process_path(&mut self, id: NodeId, path: &ast::Path, ref_kind: Option<record
                 if !self.span.filter_generated(Some(vrd.span), path.span) {
                     match ref_kind {
                         Some(recorder::TypeRef) => {
-                            self.dumper.type_ref(path.span, TypeRefData {
+                            self.dumper.type_ref(TypeRefData {
                                 span: vrd.span,
                                 ref_id: Some(vrd.ref_id),
                                 scope: vrd.scope,
@@ -767,14 +767,14 @@ fn process_path(&mut self, id: NodeId, path: &ast::Path, ref_kind: Option<record
                             }.normalize(&self.tcx));
                         }
                         Some(recorder::FnRef) => {
-                            self.dumper.function_ref(path.span, FunctionRefData {
+                            self.dumper.function_ref(FunctionRefData {
                                 span: vrd.span,
                                 ref_id: vrd.ref_id,
                                 scope: vrd.scope
                             }.normalize(&self.tcx));
                         }
                         Some(recorder::ModRef) => {
-                            self.dumper.mod_ref(path.span, ModRefData {
+                            self.dumper.mod_ref( ModRefData {
                                 span: vrd.span,
                                 ref_id: Some(vrd.ref_id),
                                 scope: vrd.scope,
@@ -782,24 +782,24 @@ fn process_path(&mut self, id: NodeId, path: &ast::Path, ref_kind: Option<record
                             }.normalize(&self.tcx));
                         }
                         Some(recorder::VarRef) | None
-                            => self.dumper.variable_ref(path.span, vrd.normalize(&self.tcx))
+                            => self.dumper.variable_ref(vrd.normalize(&self.tcx))
                     }
                 }
 
             }
             Data::TypeRefData(trd) => {
                 if !self.span.filter_generated(Some(trd.span), path.span) {
-                    self.dumper.type_ref(path.span, trd.normalize(&self.tcx));
+                    self.dumper.type_ref(trd.normalize(&self.tcx));
                 }
             }
             Data::MethodCallData(mcd) => {
                 if !self.span.filter_generated(Some(mcd.span), path.span) {
-                    self.dumper.method_call(path.span, mcd.normalize(&self.tcx));
+                    self.dumper.method_call(mcd.normalize(&self.tcx));
                 }
             }
             Data::FunctionCallData(fcd) => {
                 if !self.span.filter_generated(Some(fcd.span), path.span) {
-                    self.dumper.function_call(path.span, fcd.normalize(&self.tcx));
+                    self.dumper.function_call(fcd.normalize(&self.tcx));
                 }
             }
             _ => {
@@ -841,7 +841,7 @@ fn process_struct_lit(&mut self,
         if let Some(struct_lit_data) = self.save_ctxt.get_expr_data(ex) {
             down_cast_data!(struct_lit_data, TypeRefData, ex.span);
             if !self.span.filter_generated(Some(struct_lit_data.span), ex.span) {
-                self.dumper.type_ref(ex.span, struct_lit_data.normalize(&self.tcx));
+                self.dumper.type_ref(struct_lit_data.normalize(&self.tcx));
             }
 
             let scope = self.save_ctxt.enclosing_scope(ex.id);
@@ -851,7 +851,7 @@ fn process_struct_lit(&mut self,
                                               .get_field_ref_data(field, variant, scope) {
 
                     if !self.span.filter_generated(Some(field_data.span), field.ident.span) {
-                        self.dumper.variable_ref(field.ident.span, field_data.normalize(&self.tcx));
+                        self.dumper.variable_ref(field_data.normalize(&self.tcx));
                     }
                 }
 
@@ -866,7 +866,7 @@ fn process_method_call(&mut self, ex: &ast::Expr, args: &Vec<P<ast::Expr>>) {
         if let Some(mcd) = self.save_ctxt.get_expr_data(ex) {
             down_cast_data!(mcd, MethodCallData, ex.span);
             if !self.span.filter_generated(Some(mcd.span), ex.span) {
-                self.dumper.method_call(ex.span, mcd.normalize(&self.tcx));
+                self.dumper.method_call(mcd.normalize(&self.tcx));
             }
         }
 
@@ -886,7 +886,7 @@ fn process_pat(&mut self, p: &ast::Pat) {
                     let sub_span = self.span.span_for_first_ident(span);
                     if let Some(f) = variant.find_field_named(field.ident.name) {
                         if !self.span.filter_generated(sub_span, span) {
-                            self.dumper.variable_ref(span, VariableRefData {
+                            self.dumper.variable_ref(VariableRefData {
                                 span: sub_span.expect("No span fund for var ref"),
                                 ref_id: f.did,
                                 scope: self.cur_scope,
@@ -922,7 +922,7 @@ fn process_var_decl(&mut self, p: &ast::Pat, value: String) {
             let sub_span = self.span.span_for_last_ident(p.span);
             // Rust uses the id of the pattern for var lookups, so we'll use it too.
             if !self.span.filter_generated(sub_span, p.span) {
-                self.dumper.variable(p.span, VariableData {
+                self.dumper.variable(VariableData {
                     span: sub_span.expect("No span found for variable"),
                     id: id,
                     name: path_to_string(p),
@@ -956,7 +956,7 @@ fn process_macro_use(&mut self, span: Span, id: NodeId) {
             && !data.imported {
             self.mac_defs.insert(data.callee_span);
             if let Some(sub_span) = self.span.span_for_macro_def_name(data.callee_span) {
-                self.dumper.macro_data(data.callee_span, MacroData {
+                self.dumper.macro_data(MacroData {
                     span: sub_span,
                     name: data.name.clone(),
                     qualname: qualname.clone()
@@ -966,7 +966,7 @@ fn process_macro_use(&mut self, span: Span, id: NodeId) {
         if !self.mac_uses.contains(&data.span) {
             self.mac_uses.insert(data.span);
             if let Some(sub_span) = self.span.span_for_macro_use_name(data.span) {
-                self.dumper.macro_use(data.span, MacroUseData {
+                self.dumper.macro_use(MacroUseData {
                     span: sub_span,
                     name: data.name,
                     qualname: qualname,
@@ -1007,7 +1007,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                         };
 
                         if !self.span.filter_generated(sub_span, path.span) {
-                            self.dumper.use_data(path.span, UseData {
+                            self.dumper.use_data(UseData {
                                 span: sub_span.expect("No span found for use"),
                                 id: item.id,
                                 mod_id: mod_id,
@@ -1031,7 +1031,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                         let sub_span = self.span
                                            .sub_span_of_token(path.span, token::BinOp(token::Star));
                         if !self.span.filter_generated(sub_span, path.span) {
-                            self.dumper.use_glob(path.span, UseGlobData {
+                            self.dumper.use_glob(UseGlobData {
                                 span: sub_span.expect("No span found for use glob"),
                                 id: item.id,
                                 names: names,
@@ -1073,7 +1073,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                 };
 
                 if !self.span.filter_generated(alias_span, item.span) {
-                    self.dumper.extern_crate(item.span, ExternCrateData {
+                    self.dumper.extern_crate(ExternCrateData {
                         id: item.id,
                         name: item.ident.to_string(),
                         crate_num: cnum,
@@ -1109,7 +1109,7 @@ fn visit_item(&mut self, item: &ast::Item) {
                 let value = ty_to_string(&ty);
                 let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Type);
                 if !self.span.filter_generated(sub_span, item.span) {
-                    self.dumper.typedef(item.span, TypedefData {
+                    self.dumper.typedef(TypedefData {
                         span: sub_span.expect("No span found for typedef"),
                         id: item.id,
                         qualname: qualname.clone(),
@@ -1189,7 +1189,7 @@ fn visit_ty(&mut self, t: &ast::Ty) {
                 if let Some(id) = self.lookup_type_ref(t.id) {
                     let sub_span = self.span.sub_span_for_type_name(t.span);
                     if !self.span.filter_generated(sub_span, t.span) {
-                        self.dumper.type_ref(t.span, TypeRefData {
+                        self.dumper.type_ref(TypeRefData {
                             span: sub_span.expect("No span found for type ref"),
                             ref_id: Some(id),
                             scope: self.cur_scope,
@@ -1231,7 +1231,7 @@ fn visit_expr(&mut self, ex: &ast::Expr) {
                 if let Some(field_data) = self.save_ctxt.get_expr_data(ex) {
                     down_cast_data!(field_data, VariableRefData, ex.span);
                     if !self.span.filter_generated(Some(field_data.span), ex.span) {
-                        self.dumper.variable_ref(ex.span, field_data.normalize(&self.tcx));
+                        self.dumper.variable_ref(field_data.normalize(&self.tcx));
                     }
                 }
             }
@@ -1244,7 +1244,7 @@ fn visit_expr(&mut self, ex: &ast::Expr) {
                     ty::TyStruct(def, _) => {
                         let sub_span = self.span.sub_span_after_token(ex.span, token::Dot);
                         if !self.span.filter_generated(sub_span, ex.span) {
-                            self.dumper.variable_ref(ex.span, VariableRefData {
+                            self.dumper.variable_ref(VariableRefData {
                                 span: sub_span.expect("No span found for var ref"),
                                 ref_id: def.struct_variant().fields[idx.node].did,
                                 scope: self.cur_scope,
@@ -1334,7 +1334,7 @@ fn visit_arm(&mut self, arm: &ast::Arm) {
                     assert!(p.segments.len() == 1,
                             "qualified path for local variable def in arm");
                     if !self.span.filter_generated(Some(p.span), p.span) {
-                        self.dumper.variable(p.span, VariableData {
+                        self.dumper.variable(VariableData {
                             span: p.span,
                             id: id,
                             name: path_to_string(p),