Fix translation of external spans.

ibabushkin · ibabushkin · commit 9a054f2002e5 · 2017-06-07T16:31:05.000+02:00
diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs
@@ -232,7 +232,7 @@ pub trait CrateStore {
 
     // item info
     fn visibility(&self, def: DefId) -> ty::Visibility;
-    fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>>;
+    fn visible_parent_map<'a>(&'a self, sess: &Session) -> ::std::cell::Ref<'a, DefIdMap<DefId>>;
     fn item_generics_cloned(&self, def: DefId) -> ty::Generics;
 
     // trait info
@@ -285,7 +285,7 @@ pub trait CrateStore {
     fn def_path_hash(&self, def: DefId) -> hir_map::DefPathHash;
     fn def_path_table(&self, cnum: CrateNum) -> Rc<DefPathTable>;
     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
-    fn item_children(&self, did: DefId) -> Vec<def::Export>;
+    fn item_children(&self, did: DefId, sess: &Session) -> Vec<def::Export>;
     fn load_macro(&self, did: DefId, sess: &Session) -> LoadedMacro;
 
     // misc. metadata
@@ -347,7 +347,9 @@ impl CrateStore for DummyCrateStore {
         { bug!("crate_data_as_rc_any") }
     // item info
     fn visibility(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
-    fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {
+    fn visible_parent_map<'a>(&'a self, session: &Session)
+        -> ::std::cell::Ref<'a, DefIdMap<DefId>>
+    {
         bug!("visible_parent_map")
     }
     fn item_generics_cloned(&self, def: DefId) -> ty::Generics
@@ -421,7 +423,9 @@ impl CrateStore for DummyCrateStore {
         bug!("def_path_table")
     }
     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name> { bug!("struct_field_names") }
-    fn item_children(&self, did: DefId) -> Vec<def::Export> { bug!("item_children") }
+    fn item_children(&self, did: DefId, sess: &Session) -> Vec<def::Export> {
+        bug!("item_children")
+    }
     fn load_macro(&self, did: DefId, sess: &Session) -> LoadedMacro { bug!("load_macro") }
 
     // misc. metadata
diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs
@@ -129,7 +129,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn try_push_visible_item_path<T>(self, buffer: &mut T, external_def_id: DefId) -> bool
         where T: ItemPathBuffer
     {
-        let visible_parent_map = self.sess.cstore.visible_parent_map();
+        let visible_parent_map = self.sess.cstore.visible_parent_map(self.sess);
 
         let (mut cur_def, mut cur_path) = (external_def_id, Vec::<ast::Name>::new());
         loop {
diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs
@@ -80,7 +80,7 @@ provide! { <'tcx> tcx, def_id, cdata
     variances_of => { Rc::new(cdata.get_item_variances(def_id.index)) }
     associated_item_def_ids => {
         let mut result = vec![];
-        cdata.each_child_of_item(def_id.index, |child| result.push(child.def.def_id()));
+        cdata.each_child_of_item(def_id.index, |child| result.push(child.def.def_id()), tcx.sess);
         Rc::new(result)
     }
     associated_item => { cdata.get_associated_item(def_id.index) }
@@ -348,12 +348,12 @@ impl CrateStore for cstore::CStore {
         self.get_crate_data(def.krate).get_struct_field_names(def.index)
     }
 
-    fn item_children(&self, def_id: DefId) -> Vec<def::Export>
+    fn item_children(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>
     {
         self.dep_graph.read(DepNode::MetaData(def_id));
         let mut result = vec![];
         self.get_crate_data(def_id.krate)
-            .each_child_of_item(def_id.index, |child| result.push(child));
+            .each_child_of_item(def_id.index, |child| result.push(child), sess);
         result
     }
 
@@ -456,7 +456,7 @@ impl CrateStore for cstore::CStore {
     /// Returns a map from a sufficiently visible external item (i.e. an external item that is
     /// visible from at least one local module) to a sufficiently visible parent (considering
     /// modules that re-export the external item to be parents).
-    fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {
+    fn visible_parent_map<'a>(&'a self, sess: &Session) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {
         {
             let visible_parent_map = self.visible_parent_map.borrow();
             if !visible_parent_map.is_empty() {
@@ -506,7 +506,7 @@ impl CrateStore for cstore::CStore {
                 index: CRATE_DEF_INDEX
             });
             while let Some(def) = bfs_queue.pop_front() {
-                for child in self.item_children(def) {
+                for child in self.item_children(def, sess) {
                     add_child(bfs_queue, child, def);
                 }
             }
diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs
@@ -653,7 +653,7 @@ impl<'a, 'tcx> CrateMetadata {
     }
 
     /// Iterates over each child of the given item.
-    pub fn each_child_of_item<F>(&self, id: DefIndex, mut callback: F)
+    pub fn each_child_of_item<F>(&self, id: DefIndex, mut callback: F, sess: &Session)
         where F: FnMut(def::Export)
     {
         if let Some(ref proc_macros) = self.proc_macros {
@@ -676,19 +676,19 @@ impl<'a, 'tcx> CrateMetadata {
         // Find the item.
         let item = match self.maybe_entry(id) {
             None => return,
-            Some(item) => item.decode(self),
+            Some(item) => item.decode((self, sess)),
         };
 
         // Iterate over all children.
         let macros_only = self.dep_kind.get().macros_only();
-        for child_index in item.children.decode(self) {
+        for child_index in item.children.decode((self, sess)) {
             if macros_only {
                 continue
             }
 
             // Get the item.
             if let Some(child) = self.maybe_entry(child_index) {
-                let child = child.decode(self);
+                let child = child.decode((self, sess));
                 match child.kind {
                     EntryKind::MacroDef(..) => {}
                     _ if macros_only => continue,
@@ -699,12 +699,12 @@ impl<'a, 'tcx> CrateMetadata {
                 match child.kind {
                     // FIXME(eddyb) Don't encode these in children.
                     EntryKind::ForeignMod => {
-                        for child_index in child.children.decode(self) {
+                        for child_index in child.children.decode((self, sess)) {
                             if let Some(def) = self.get_def(child_index) {
                                 callback(def::Export {
                                     def: def,
                                     ident: Ident::with_empty_ctxt(self.item_name(child_index)),
-                                    span: self.entry(child_index).span.decode(self),
+                                    span: self.entry(child_index).span.decode((self, sess)),
                                 });
                             }
                         }
@@ -717,7 +717,7 @@ impl<'a, 'tcx> CrateMetadata {
                 }
 
                 let def_key = self.def_key(child_index);
-                let span = child.span.decode(self);
+                let span = child.span.decode((self, sess));
                 if let (Some(def), Some(name)) =
                     (self.get_def(child_index), def_key.disambiguated_data.data.get_opt_name()) {
                     let ident = Ident::with_empty_ctxt(name);
@@ -746,7 +746,7 @@ impl<'a, 'tcx> CrateMetadata {
         }
 
         if let EntryKind::Mod(data) = item.kind {
-            for exp in data.decode(self).reexports.decode(self) {
+            for exp in data.decode((self, sess)).reexports.decode((self, sess)) {
                 match exp.def {
                     Def::Macro(..) => {}
                     _ if macros_only => continue,
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
@@ -478,7 +478,7 @@ impl<'a> Resolver<'a> {
                                              span);
                 self.define(parent, ident, TypeNS, (module, vis, DUMMY_SP, expansion));
 
-                for child in self.session.cstore.item_children(def_id) {
+                for child in self.session.cstore.item_children(def_id, self.session) {
                     let ns = if let Def::AssociatedTy(..) = child.def { TypeNS } else { ValueNS };
                     self.define(module, child.ident, ns,
                                 (child.def, ty::Visibility::Public, DUMMY_SP, expansion));
@@ -564,7 +564,7 @@ impl<'a> Resolver<'a> {
     /// is built, building it if it is not.
     pub fn populate_module_if_necessary(&mut self, module: Module<'a>) {
         if module.populated.get() { return }
-        for child in self.session.cstore.item_children(module.def_id().unwrap()) {
+        for child in self.session.cstore.item_children(module.def_id().unwrap(), self.session) {
             self.build_reduced_graph_for_external_crate_def(module, child);
         }
         module.populated.set(true)
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
@@ -526,7 +526,7 @@ pub fn all_traits<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> AllTraits<'a>
                     if !external_mods.insert(def_id) {
                         return;
                     }
-                    for child in tcx.sess.cstore.item_children(def_id) {
+                    for child in tcx.sess.cstore.item_children(def_id, tcx.sess) {
                         handle_external_def(tcx, traits, external_mods, child.def)
                     }
                 }
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
@@ -443,7 +443,7 @@ fn build_module(cx: &DocContext, did: DefId) -> clean::Module {
         // two namespaces, so the target may be listed twice. Make sure we only
         // visit each node at most once.
         let mut visited = FxHashSet();
-        for item in cx.tcx.sess.cstore.item_children(did) {
+        for item in cx.tcx.sess.cstore.item_children(did, cx.tcx.sess) {
             let def_id = item.def.def_id();
             if cx.tcx.sess.cstore.visibility(def_id) == ty::Visibility::Public {
                 if !visited.insert(def_id) { continue }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -241,7 +241,7 @@ impl Clean<ExternalCrate> for CrateNum {
                 }
             }).collect()
         } else {
-            cx.tcx.sess.cstore.item_children(root).iter().map(|item| item.def)
+            cx.tcx.sess.cstore.item_children(root, cx.tcx.sess).iter().map(|item| item.def)
               .filter_map(as_primitive).collect()
         };
 
diff --git a/src/librustdoc/visit_lib.rs b/src/librustdoc/visit_lib.rs
@@ -70,7 +70,7 @@ impl<'a, 'b, 'tcx> LibEmbargoVisitor<'a, 'b, 'tcx> {
             return;
         }
 
-        for item in self.cstore.item_children(def_id) {
+        for item in self.cstore.item_children(def_id, self.cx.tcx.sess) {
             self.visit_item(item.def);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`129`	`129`	`pub fn try_push_visible_item_path<T>(self, buffer: &mut T, external_def_id: DefId) -> bool`
`130`	`130`	`where T: ItemPathBuffer`
`131`	`131`	`{`
`132`		`- let visible_parent_map = self.sess.cstore.visible_parent_map();`
	`132`	`+ let visible_parent_map = self.sess.cstore.visible_parent_map(self.sess);`
`133`	`133`
`134`	`134`	`let (mut cur_def, mut cur_path) = (external_def_id, Vec::<ast::Name>::new());`
`135`	`135`	`loop {`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ provide! { <'tcx> tcx, def_id, cdata`
`80`	`80`	`variances_of => { Rc::new(cdata.get_item_variances(def_id.index)) }`
`81`	`81`	`associated_item_def_ids => {`
`82`	`82`	`let mut result = vec![];`
`83`		`- cdata.each_child_of_item(def_id.index, \|child\| result.push(child.def.def_id()));`
	`83`	`+ cdata.each_child_of_item(def_id.index, \|child\| result.push(child.def.def_id()), tcx.sess);`
`84`	`84`	`Rc::new(result)`
`85`	`85`	`}`
`86`	`86`	`associated_item => { cdata.get_associated_item(def_id.index) }`
`@@ -348,12 +348,12 @@ impl CrateStore for cstore::CStore {`
`348`	`348`	`self.get_crate_data(def.krate).get_struct_field_names(def.index)`
`349`	`349`	`}`
`350`	`350`
`351`		`- fn item_children(&self, def_id: DefId) -> Vec<def::Export>`
	`351`	`+ fn item_children(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>`
`352`	`352`	`{`
`353`	`353`	`self.dep_graph.read(DepNode::MetaData(def_id));`
`354`	`354`	`let mut result = vec![];`
`355`	`355`	`self.get_crate_data(def_id.krate)`
`356`		`- .each_child_of_item(def_id.index, \|child\| result.push(child));`
	`356`	`+ .each_child_of_item(def_id.index, \|child\| result.push(child), sess);`
`357`	`357`	`result`
`358`	`358`	`}`
`359`	`359`
`@@ -456,7 +456,7 @@ impl CrateStore for cstore::CStore {`
`456`	`456`	`/// Returns a map from a sufficiently visible external item (i.e. an external item that is`
`457`	`457`	`/// visible from at least one local module) to a sufficiently visible parent (considering`
`458`	`458`	`/// modules that re-export the external item to be parents).`
`459`		`- fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {`
	`459`	`+ fn visible_parent_map<'a>(&'a self, sess: &Session) -> ::std::cell::Ref<'a, DefIdMap<DefId>> {`
`460`	`460`	`{`
`461`	`461`	`let visible_parent_map = self.visible_parent_map.borrow();`
`462`	`462`	`if !visible_parent_map.is_empty() {`
`@@ -506,7 +506,7 @@ impl CrateStore for cstore::CStore {`
`506`	`506`	`index: CRATE_DEF_INDEX`
`507`	`507`	`});`
`508`	`508`	`while let Some(def) = bfs_queue.pop_front() {`
`509`		`- for child in self.item_children(def) {`
	`509`	`+ for child in self.item_children(def, sess) {`
`510`	`510`	`add_child(bfs_queue, child, def);`
`511`	`511`	`}`
`512`	`512`	`}`
Original file line number	Diff line number	Diff line change
`@@ -526,7 +526,7 @@ pub fn all_traits<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> AllTraits<'a>`
`526`	`526`	`if !external_mods.insert(def_id) {`
`527`	`527`	`return;`
`528`	`528`	`}`
`529`		`- for child in tcx.sess.cstore.item_children(def_id) {`
	`529`	`+ for child in tcx.sess.cstore.item_children(def_id, tcx.sess) {`
`530`	`530`	`handle_external_def(tcx, traits, external_mods, child.def)`
`531`	`531`	`}`
`532`	`532`	`}`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ impl Clean<ExternalCrate> for CrateNum {`
`241`	`241`	`}`
`242`	`242`	`}).collect()`
`243`	`243`	`} else {`
`244`		`- cx.tcx.sess.cstore.item_children(root).iter().map(\|item\| item.def)`
	`244`	`+ cx.tcx.sess.cstore.item_children(root, cx.tcx.sess).iter().map(\|item\| item.def)`
`245`	`245`	`.filter_map(as_primitive).collect()`
`246`	`246`	`};`
`247`	`247`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ impl<'a, 'b, 'tcx> LibEmbargoVisitor<'a, 'b, 'tcx> {`
`70`	`70`	`return;`
`71`	`71`	`}`
`72`	`72`
`73`		`- for item in self.cstore.item_children(def_id) {`
	`73`	`+ for item in self.cstore.item_children(def_id, self.cx.tcx.sess) {`
`74`	`74`	`self.visit_item(item.def);`
`75`	`75`	`}`
`76`	`76`	`}`