rustc: Flag some CrateStore methods as "untracked"

[rust.git] / src / librustc_resolve / build_reduced_graph.rs

diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
index 47fa5357abf0d64b50e6ef7b131d8c4a7cbd2cc0..776ec3fd3f998d6dd2de5ac94b4d080ac7e3b3b3 100644 (file)
--- a/src/librustc_resolve/build_reduced_graph.rs
+++ b/src/librustc_resolve/build_reduced_graph.rs
@@ -253,7 +253,7 @@ fn build_reduced_graph_for_item(&mut self, item: &Item, expansion: Mark) {
                 self.crate_loader.process_item(item, &self.definitions);
 
                 // n.b. we don't need to look at the path option here, because cstore already did
-                let crate_id = self.session.cstore.extern_mod_stmt_cnum(item.id).unwrap();
+                let crate_id = self.session.cstore.extern_mod_stmt_cnum_untracked(item.id).unwrap();
                 let module =
                     self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
                 self.populate_module_if_necessary(module);
@@ -449,7 +449,7 @@ fn build_reduced_graph_for_external_crate_def(&mut self, parent: Module<'a>, chi
         let ident = child.ident;
         let def = child.def;
         let def_id = def.def_id();
-        let vis = self.session.cstore.visibility(def_id);
+        let vis = self.session.cstore.visibility_untracked(def_id);
         let span = child.span;
         let expansion = Mark::root(); // FIXME(jseyfried) intercrate hygiene
         match def {
@@ -485,7 +485,7 @@ fn build_reduced_graph_for_external_crate_def(&mut self, parent: Module<'a>, chi
                                              span);
                 self.define(parent, ident, TypeNS, (module, vis, DUMMY_SP, expansion));
 
-                for child in self.session.cstore.item_children(def_id, self.session) {
+                for child in self.session.cstore.item_children_untracked(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));
@@ -501,7 +501,7 @@ fn build_reduced_graph_for_external_crate_def(&mut self, parent: Module<'a>, chi
                 self.define(parent, ident, TypeNS, (def, vis, DUMMY_SP, expansion));
 
                 // Record field names for error reporting.
-                let field_names = self.session.cstore.struct_field_names(def_id);
+                let field_names = self.session.cstore.struct_field_names_untracked(def_id);
                 self.insert_field_names(def_id, field_names);
             }
             Def::Macro(..) => {
@@ -516,13 +516,13 @@ pub fn get_module(&mut self, def_id: DefId) -> Module<'a> {
             return self.module_map[&def_id]
         }
 
-        let macros_only = self.session.cstore.dep_kind(def_id.krate).macros_only();
+        let macros_only = self.session.cstore.dep_kind_untracked(def_id.krate).macros_only();
         if let Some(&module) = self.extern_module_map.get(&(def_id, macros_only)) {
             return module;
         }
 
         let (name, parent) = if def_id.index == CRATE_DEF_INDEX {
-            (self.session.cstore.crate_name(def_id.krate), None)
+            (self.session.cstore.crate_name_untracked(def_id.krate), None)
         } else {
             let def_key = self.session.cstore.def_key(def_id);
             (def_key.disambiguated_data.data.get_opt_name().unwrap(),
@@ -558,7 +558,7 @@ pub fn get_macro(&mut self, def: Def) -> Rc<SyntaxExtension> {
             return ext.clone();
         }
 
-        let macro_def = match self.session.cstore.load_macro(def_id, &self.session) {
+        let macro_def = match self.session.cstore.load_macro_untracked(def_id, &self.session) {
             LoadedMacro::MacroDef(macro_def) => macro_def,
             LoadedMacro::ProcMacro(ext) => return ext,
         };
@@ -574,7 +574,8 @@ pub fn get_macro(&mut self, def: Def) -> Rc<SyntaxExtension> {
     /// 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(), self.session) {
+        let def_id = module.def_id().unwrap();
+        for child in self.session.cstore.item_children_untracked(def_id, self.session) {
             self.build_reduced_graph_for_external_crate_def(module, child);
         }
         module.populated.set(true)
@@ -605,7 +606,8 @@ fn process_legacy_macro_imports(&mut self, item: &Item, module: Module<'a>, expa
             span_err!(self.session, item.span, E0468,
                       "an `extern crate` loading macros must be at the crate root");
         } else if !self.use_extern_macros && !used &&
-                  self.session.cstore.dep_kind(module.def_id().unwrap().krate).macros_only() {
+                  self.session.cstore.dep_kind_untracked(module.def_id().unwrap().krate)
+                      .macros_only() {
             let msg = "proc macro crates and `#[no_link]` crates have no effect without \
                        `#[macro_use]`";
             self.session.span_warn(item.span, msg);
@@ -648,7 +650,7 @@ fn process_legacy_macro_imports(&mut self, item: &Item, module: Module<'a>, expa
             }
         }
         for (name, span) in legacy_imports.reexports {
-            self.session.cstore.export_macros(module.def_id().unwrap().krate);
+            self.session.cstore.export_macros_untracked(module.def_id().unwrap().krate);
             let ident = Ident::with_empty_ctxt(name);
             let result = self.resolve_ident_in_module(module, ident, MacroNS, false, false, span);
             if let Ok(binding) = result {