Make CrateMetadata dep_kind private

Author: spastorino

src/librustc_metadata/creader.rs

@@ -49,7 +49,7 @@ fn dump_crates(cstore: &CStore) {
         info!("  name: {}", data.root.name);
         info!("  cnum: {}", data.cnum);
         info!("  hash: {}", data.root.hash);
-        info!("  reqd: {:?}", *data.dep_kind.lock());
+        info!("  reqd: {:?}", data.get_dep_kind());
         let CrateSource { dylib, rlib, rmeta } = data.source.clone();
         dylib.map(|dl| info!("  dylib: {}", dl.0.display()));
         rlib.map(|rl|  info!("   rlib: {}", rl.0.display()));
@@ -375,9 +375,7 @@ impl<'a> CrateLoader<'a> {
                 if data.root.proc_macro_data.is_some() {
                     dep_kind = DepKind::UnexportedMacrosOnly;
                 }
-                data.dep_kind.with_lock(|data_dep_kind| {
-                    *data_dep_kind = cmp::max(*data_dep_kind, dep_kind);
-                });
+                data.set_max_dep_kind(dep_kind);
                 Ok(cnum)
             }
             (LoadResult::Loaded(library), host_library) => {
@@ -549,7 +547,7 @@ impl<'a> CrateLoader<'a> {
                 // #![panic_runtime] crate.
                 self.inject_dependency_if(cnum, "a panic runtime",
                                           &|data| data.root.needs_panic_runtime);
-                runtime_found = runtime_found || *data.dep_kind.lock() == DepKind::Explicit;
+                runtime_found = runtime_found || data.get_dep_kind() == DepKind::Explicit;
             }
         });
 

src/librustc_metadata/cstore.rs

@@ -30,6 +30,7 @@ use syntax_expand::base::{SyntaxExtensionKind, SyntaxExtension};
 use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
 use syntax_pos::{self, Span, Pos, DUMMY_SP, hygiene::MacroKind};
 use syntax_pos::symbol::{Symbol, sym};
+use std::cmp;
 
 pub use crate::cstore_impl::{provide, provide_extern};
 
@@ -96,7 +97,7 @@ crate struct CrateMetadata {
     /// Same ID set as `cnum_map` plus maybe some injected crates like panic runtime.
     crate dependencies: Lock<Vec<CrateNum>>,
     /// How to link (or not link) this crate to the currently compiled crate.
-    crate dep_kind: Lock<DepKind>,
+    dep_kind: Lock<DepKind>,
     /// Filesystem location of this crate.
     crate source: CrateSource,
     /// Whether or not this crate should be consider a private dependency
@@ -446,6 +447,23 @@ impl<'a, 'tcx> CrateMetadata {
         }
     }
 
+    crate fn get_dep_kind(&self) -> DepKind {
+        *self.dep_kind.lock()
+    }
+
+    crate fn export_macros_untracked(&self) {
+        let mut dep_kind = self.dep_kind.lock();
+        if *dep_kind == DepKind::UnexportedMacrosOnly {
+            *dep_kind = DepKind::MacrosOnly;
+        }
+    }
+
+    crate fn set_max_dep_kind(&self, dep_kind: DepKind) {
+        self.dep_kind.with_lock(|data_dep_kind| {
+            *data_dep_kind = cmp::max(*data_dep_kind, dep_kind);
+        });
+    }
+
     /// Iterates over the diagnostic items in the given crate.
     crate fn get_diagnostic_items(
         &self,

src/librustc_metadata/cstore_impl.rs

@@ -6,7 +6,7 @@ use crate::foreign_modules;
 use crate::schema;
 
 use rustc::ty::query::QueryConfig;
-use rustc::middle::cstore::{CrateSource, CrateStore, DepKind, EncodedMetadata, NativeLibraryKind};
+use rustc::middle::cstore::{CrateSource, CrateStore, EncodedMetadata, NativeLibraryKind};
 use rustc::middle::exported_symbols::ExportedSymbol;
 use rustc::middle::stability::DeprecationEntry;
 use rustc::middle::dependency_format::Linkage;
@@ -210,8 +210,7 @@ provide! { <'tcx> tcx, def_id, other, cdata,
 
     visibility => { cdata.get_visibility(def_id.index) }
     dep_kind => {
-        let r = *cdata.dep_kind.lock();
-        r
+        cdata.get_dep_kind()
     }
     crate_name => { cdata.root.name }
     item_children => {
@@ -404,10 +403,7 @@ pub fn provide(providers: &mut Providers<'_>) {
 impl cstore::CStore {
     pub fn export_macros_untracked(&self, cnum: CrateNum) {
         let data = self.get_crate_data(cnum);
-        let mut dep_kind = data.dep_kind.lock();
-        if *dep_kind == DepKind::UnexportedMacrosOnly {
-            *dep_kind = DepKind::MacrosOnly;
-        }
+        data.export_macros_untracked();
     }
 
     pub fn struct_field_names_untracked(&self, def: DefId, sess: &Session) -> Vec<Spanned<Symbol>> {