Use config::pub_only rather than a spearate api mode

nrc · nrc · commit 52e9f2035ae3 · 2017-07-22T16:35:40.000+12:00
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
@@ -960,9 +960,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
     save_analysis: bool = (false, parse_bool, [UNTRACKED],
         "write syntax and type analysis (in JSON format) information, in \
          addition to normal output"),
-    save_analysis_api: bool = (false, parse_bool, [UNTRACKED],
-        "write syntax and type analysis information for opaque libraries (in JSON format), \
-         in addition to normal output"),
     print_move_fragments: bool = (false, parse_bool, [UNTRACKED],
         "print out move-fragment data for every fn"),
     flowgraph_print_loans: bool = (false, parse_bool, [UNTRACKED],
@@ -2527,8 +2524,6 @@ mod tests {
         assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
         opts.debugging_opts.save_analysis = true;
         assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
-        opts.debugging_opts.save_analysis_api = true;
-        assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
         opts.debugging_opts.print_move_fragments = true;
         assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
         opts.debugging_opts.flowgraph_print_loans = true;
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
@@ -579,8 +579,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
                                         state.analysis.unwrap(),
                                         state.crate_name.unwrap(),
                                         None,
-                                        DumpHandler::new(save_analysis_format(state.session),
-                                                         state.out_dir,
+                                        DumpHandler::new(state.out_dir,
                                                          state.crate_name.unwrap()))
                 });
             };
@@ -603,18 +602,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
 }
 
 fn save_analysis(sess: &Session) -> bool {
-    sess.opts.debugging_opts.save_analysis ||
-    sess.opts.debugging_opts.save_analysis_api
-}
-
-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_api {
-        save::Format::JsonApi
-    } else {
-        unreachable!();
-    }
+    sess.opts.debugging_opts.save_analysis
 }
 
 impl RustcDefaultCalls {
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -41,7 +41,8 @@ use syntax::ptr::P;
 use syntax::codemap::Spanned;
 use syntax_pos::*;
 
-use {escape, generated_code, SaveContext, PathCollector, lower_attributes, Dump};
+use {escape, generated_code, SaveContext, PathCollector, lower_attributes};
+use json_dumper::{JsonDumper, DumpOutput};
 use span_utils::SpanUtils;
 use sig;
 
@@ -58,11 +59,11 @@ macro_rules! down_cast_data {
     };
 }
 
-pub struct DumpVisitor<'l, 'tcx: 'l, 'll, D: 'll> {
+pub struct DumpVisitor<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> {
     save_ctxt: SaveContext<'l, 'tcx>,
     sess: &'l Session,
     tcx: TyCtxt<'l, 'tcx, 'tcx>,
-    dumper: &'ll mut D,
+    dumper: &'ll mut JsonDumper<O>,
 
     span: SpanUtils<'l>,
 
@@ -75,10 +76,10 @@ pub struct DumpVisitor<'l, 'tcx: 'l, 'll, D: 'll> {
     // mac_defs: HashSet<Span>,
 }
 
-impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
+impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> {
     pub fn new(save_ctxt: SaveContext<'l, 'tcx>,
-               dumper: &'ll mut D)
-               -> DumpVisitor<'l, 'tcx, 'll, D> {
+               dumper: &'ll mut JsonDumper<O>)
+               -> DumpVisitor<'l, 'tcx, 'll, O> {
         let span_utils = SpanUtils::new(&save_ctxt.tcx.sess);
         DumpVisitor {
             sess: &save_ctxt.tcx.sess,
@@ -92,7 +93,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
     }
 
     fn nest_scope<F>(&mut self, scope_id: NodeId, f: F)
-        where F: FnOnce(&mut DumpVisitor<'l, 'tcx, 'll, D>)
+        where F: FnOnce(&mut DumpVisitor<'l, 'tcx, 'll, O>)
     {
         let parent_scope = self.cur_scope;
         self.cur_scope = scope_id;
@@ -101,7 +102,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
     }
 
     fn nest_tables<F>(&mut self, item_id: NodeId, f: F)
-        where F: FnOnce(&mut DumpVisitor<'l, 'tcx, 'll, D>)
+        where F: FnOnce(&mut DumpVisitor<'l, 'tcx, 'll, O>)
     {
         let item_def_id = self.tcx.hir.local_def_id(item_id);
         if self.tcx.has_typeck_tables(item_def_id) {
@@ -1089,7 +1090,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
     }
 }
 
-impl<'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor<'l> for DumpVisitor<'l, 'tcx, 'll, D> {
+impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tcx, 'll, O> {
     fn visit_mod(&mut self, m: &'l ast::Mod, span: Span, attrs: &[ast::Attribute], id: NodeId) {
         // Since we handle explicit modules ourselves in visit_item, this should
         // only get called for the root module of a crate.
diff --git a/src/librustc_save_analysis/json_api_dumper.rs b/src/librustc_save_analysis/json_api_dumper.rs
diff --git a/src/librustc_save_analysis/json_dumper.rs b/src/librustc_save_analysis/json_dumper.rs
@@ -14,12 +14,12 @@ use rustc_serialize::json::as_json;
 
 use rls_data::{self, Analysis, Import, Def, DefKind, Ref, RefKind, MacroRef,
                Relation, CratePreludeData};
+use rls_data::config::Config;
 use rls_span::{Column, Row};
 
-use Dump;
-
 pub struct JsonDumper<O: DumpOutput> {
     result: Analysis,
+    config: Config,
     output: O,
 }
 
@@ -50,14 +50,14 @@ impl<'b> DumpOutput for CallbackOutput<'b> {
 }
 
 impl<'b, W: Write> JsonDumper<WriteOutput<'b, W>> {
-    pub fn new(writer: &'b mut W) -> JsonDumper<WriteOutput<'b, W>> {
-        JsonDumper { output: WriteOutput { output: writer }, result: Analysis::new() }
+    pub fn new(writer: &'b mut W, config: Config) -> JsonDumper<WriteOutput<'b, W>> {
+        JsonDumper { output: WriteOutput { output: writer }, config, result: Analysis::new() }
     }
 }
 
 impl<'b> JsonDumper<CallbackOutput<'b>> {
-    pub fn with_callback(callback: &'b mut FnMut(&Analysis)) -> JsonDumper<CallbackOutput<'b>> {
-        JsonDumper { output: CallbackOutput { callback: callback }, result: Analysis::new() }
+    pub fn with_callback(callback: &'b mut FnMut(&Analysis), config: Config) -> JsonDumper<CallbackOutput<'b>> {
+        JsonDumper { output: CallbackOutput { callback: callback }, config, result: Analysis::new() }
     }
 }
 
@@ -67,23 +67,36 @@ impl<O: DumpOutput> Drop for JsonDumper<O> {
     }
 }
 
-impl<'b, O: DumpOutput + 'b> Dump for JsonDumper<O> {
-    fn crate_prelude(&mut self, data: CratePreludeData) {
+impl<'b, O: DumpOutput + 'b> JsonDumper<O> {
+    pub fn crate_prelude(&mut self, data: CratePreludeData) {
         self.result.prelude = Some(data)
     }
 
-    fn macro_use(&mut self, data: MacroRef) {
+    pub fn macro_use(&mut self, data: MacroRef) {
+        if self.config.pub_only {
+            return;
+        }
         self.result.macro_refs.push(data);
     }
 
-    fn import(&mut self, _: bool, import: Import) {
+    pub fn import(&mut self, public: bool, import: Import) {
+        if !public && self.config.pub_only {
+            return;
+        }
         self.result.imports.push(import);
     }
 
-    fn dump_ref(&mut self, data: Ref) {
+    pub fn dump_ref(&mut self, data: Ref) {
+        if self.config.pub_only {
+            return;
+        }
         self.result.refs.push(data);
     }
-    fn dump_def(&mut self, _: bool, mut data: Def) {
+
+    pub fn dump_def(&mut self, public: bool, mut data: Def) {
+        if !public && self.config.pub_only {
+            return;
+        }
         if data.kind == DefKind::Mod && data.span.file_name.to_str().unwrap() != data.value {
             // If the module is an out-of-line defintion, then we'll make the
             // defintion the first character in the module's file and turn the
@@ -107,7 +120,7 @@ impl<'b, O: DumpOutput + 'b> Dump for JsonDumper<O> {
         self.result.defs.push(data);
     }
 
-    fn dump_relation(&mut self, data: Relation) {
+    pub fn dump_relation(&mut self, data: Relation) {
         self.result.relations.push(data);
     }
 }
diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,12 @@ use rustc_serialize::json::as_json;`
`14`	`14`
`15`	`15`	`use rls_data::{self, Analysis, Import, Def, DefKind, Ref, RefKind, MacroRef,`
`16`	`16`	`Relation, CratePreludeData};`
	`17`	`+use rls_data::config::Config;`
`17`	`18`	`use rls_span::{Column, Row};`
`18`	`19`
`19`		`-use Dump;`
`20`		`-`
`21`	`20`	`pub struct JsonDumper<O: DumpOutput> {`
`22`	`21`	`result: Analysis,`
	`22`	`+ config: Config,`
`23`	`23`	`output: O,`
`24`	`24`	`}`
`25`	`25`
`@@ -50,14 +50,14 @@ impl<'b> DumpOutput for CallbackOutput<'b> {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`impl<'b, W: Write> JsonDumper<WriteOutput<'b, W>> {`
`53`		`- pub fn new(writer: &'b mut W) -> JsonDumper<WriteOutput<'b, W>> {`
`54`		`- JsonDumper { output: WriteOutput { output: writer }, result: Analysis::new() }`
	`53`	`+ pub fn new(writer: &'b mut W, config: Config) -> JsonDumper<WriteOutput<'b, W>> {`
	`54`	`+ JsonDumper { output: WriteOutput { output: writer }, config, result: Analysis::new() }`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`impl<'b> JsonDumper<CallbackOutput<'b>> {`
`59`		`- pub fn with_callback(callback: &'b mut FnMut(&Analysis)) -> JsonDumper<CallbackOutput<'b>> {`
`60`		`- JsonDumper { output: CallbackOutput { callback: callback }, result: Analysis::new() }`
	`59`	`+ pub fn with_callback(callback: &'b mut FnMut(&Analysis), config: Config) -> JsonDumper<CallbackOutput<'b>> {`
	`60`	`+ JsonDumper { output: CallbackOutput { callback: callback }, config, result: Analysis::new() }`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`@@ -67,23 +67,36 @@ impl<O: DumpOutput> Drop for JsonDumper<O> {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`-impl<'b, O: DumpOutput + 'b> Dump for JsonDumper<O> {`
`71`		`- fn crate_prelude(&mut self, data: CratePreludeData) {`
	`70`	`+impl<'b, O: DumpOutput + 'b> JsonDumper<O> {`
	`71`	`+ pub fn crate_prelude(&mut self, data: CratePreludeData) {`
`72`	`72`	`self.result.prelude = Some(data)`
`73`	`73`	`}`
`74`	`74`
`75`		`- fn macro_use(&mut self, data: MacroRef) {`
	`75`	`+ pub fn macro_use(&mut self, data: MacroRef) {`
	`76`	`+ if self.config.pub_only {`
	`77`	`+ return;`
	`78`	`+ }`
`76`	`79`	`self.result.macro_refs.push(data);`
`77`	`80`	`}`
`78`	`81`
`79`		`- fn import(&mut self, _: bool, import: Import) {`
	`82`	`+ pub fn import(&mut self, public: bool, import: Import) {`
	`83`	`+ if !public && self.config.pub_only {`
	`84`	`+ return;`
	`85`	`+ }`
`80`	`86`	`self.result.imports.push(import);`
`81`	`87`	`}`
`82`	`88`
`83`		`- fn dump_ref(&mut self, data: Ref) {`
	`89`	`+ pub fn dump_ref(&mut self, data: Ref) {`
	`90`	`+ if self.config.pub_only {`
	`91`	`+ return;`
	`92`	`+ }`
`84`	`93`	`self.result.refs.push(data);`
`85`	`94`	`}`
`86`		`- fn dump_def(&mut self, _: bool, mut data: Def) {`
	`95`	`+`
	`96`	`+ pub fn dump_def(&mut self, public: bool, mut data: Def) {`
	`97`	`+ if !public && self.config.pub_only {`
	`98`	`+ return;`
	`99`	`+ }`
`87`	`100`	`if data.kind == DefKind::Mod && data.span.file_name.to_str().unwrap() != data.value {`
`88`	`101`	`// If the module is an out-of-line defintion, then we'll make the`
`89`	`102`	`// defintion the first character in the module's file and turn the`
`@@ -107,7 +120,7 @@ impl<'b, O: DumpOutput + 'b> Dump for JsonDumper<O> {`
`107`	`120`	`self.result.defs.push(data);`
`108`	`121`	`}`
`109`	`122`
`110`		`- fn dump_relation(&mut self, data: Relation) {`
	`123`	`+ pub fn dump_relation(&mut self, data: Relation) {`
`111`	`124`	`self.result.relations.push(data);`
`112`	`125`	`}`
`113`	`126`	`}`