Always execute crates.

This commit stops `crates` from being a query so that it will always
execute. This is required as speculative loading of crates for
diagnostic purposes will add new crate numbers that `crates` would
not include when cached.

Author: davidtwco

src/librustc/dep_graph/dep_node.rs

@@ -639,7 +639,6 @@ define_dep_nodes!( <'tcx>
     [input] NamesImportedByGlobUse(DefId),
     [eval_always] StabilityIndex,
     [eval_always] AllSuggestibleTraits,
-    [input] AllCrateNums,
     [] ExportedSymbols(CrateNum),
     [eval_always] CollectAndPartitionMonoItems,
     [] IsCodegenedItem(DefId),

src/librustc/ty/context.rs

@@ -1334,8 +1334,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.stability_index(LOCAL_CRATE)
     }
 
-    pub fn crates(self) -> Lrc<Vec<CrateNum>> {
-        self.all_crate_nums(LOCAL_CRATE)
+    pub fn crates(self) -> Vec<CrateNum> {
+        self.cstore.crates_untracked()
     }
 
     pub fn features(self) -> Lrc<feature_gate::Features> {
@@ -3031,10 +3031,6 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
         let id = tcx.hir().as_local_node_id(id).unwrap();
         tcx.cstore.extern_mod_stmt_cnum_untracked(id)
     };
-    providers.all_crate_nums = |tcx, cnum| {
-        assert_eq!(cnum, LOCAL_CRATE);
-        Lrc::new(tcx.cstore.crates_untracked())
-    };
     providers.postorder_cnums = |tcx, cnum| {
         assert_eq!(cnum, LOCAL_CRATE);
         Lrc::new(tcx.cstore.postorder_cnums_untracked())

src/librustc/ty/query/config.rs

@@ -844,12 +844,6 @@ impl<'tcx> QueryDescription<'tcx> for queries::all_suggestible_traits<'tcx> {
     }
 }
 
-impl<'tcx> QueryDescription<'tcx> for queries::all_crate_nums<'tcx> {
-    fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> {
-        "fetching all foreign CrateNum instances".into()
-    }
-}
-
 impl<'tcx> QueryDescription<'tcx> for queries::exported_symbols<'tcx> {
     fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> {
         "exported_symbols".into()

src/librustc/ty/query/mod.rs

@@ -558,7 +558,6 @@ define_queries! { <'tcx>
             -> Lrc<FxHashSet<ast::Name>>,
 
         [] fn stability_index: stability_index_node(CrateNum) -> Lrc<stability::Index<'tcx>>,
-        [] fn all_crate_nums: all_crate_nums_node(CrateNum) -> Lrc<Vec<CrateNum>>,
 
         /// A vector of every trait accessible in the whole crate
         /// (i.e., including those from subcrates). This is used only for
@@ -895,10 +894,6 @@ fn stability_index_node<'tcx>(_: CrateNum) -> DepConstructor<'tcx> {
     DepConstructor::StabilityIndex
 }
 
-fn all_crate_nums_node<'tcx>(_: CrateNum) -> DepConstructor<'tcx> {
-    DepConstructor::AllCrateNums
-}
-
 fn all_suggestible_traits_node<'tcx>(_: CrateNum) -> DepConstructor<'tcx> {
     DepConstructor::AllSuggestibleTraits
 }

src/librustc/ty/query/on_disk_cache.rs

@@ -429,7 +429,7 @@ impl<'sess> OnDiskCache<'sess> {
                         -> IndexVec<CrateNum, Option<CrateNum>>
     {
         tcx.dep_graph.with_ignore(|| {
-            let current_cnums = tcx.all_crate_nums(LOCAL_CRATE).iter().map(|&cnum| {
+            let current_cnums = tcx.crates().iter().map(|&cnum| {
                 let crate_name = tcx.original_crate_name(cnum)
                                     .to_string();
                 let crate_disambiguator = tcx.crate_disambiguator(cnum);

src/librustc/ty/query/plumbing.rs

@@ -1417,7 +1417,6 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,
         DepKind::MaybeUnusedExternCrates => { force!(maybe_unused_extern_crates, LOCAL_CRATE); }
         DepKind::StabilityIndex => { force!(stability_index, LOCAL_CRATE); }
         DepKind::AllSuggestibleTraits => { force!(all_suggestible_traits, LOCAL_CRATE); }
-        DepKind::AllCrateNums => { force!(all_crate_nums, LOCAL_CRATE); }
         DepKind::ExportedSymbols => { force!(exported_symbols, krate!()); }
         DepKind::CollectAndPartitionMonoItems => {
             force!(collect_and_partition_mono_items, LOCAL_CRATE);

src/librustc_codegen_ssa/back/symbol_export.rs

@@ -286,7 +286,7 @@ fn upstream_monomorphizations_provider<'a, 'tcx>(
 {
     debug_assert!(cnum == LOCAL_CRATE);
 
-    let cnums = tcx.all_crate_nums(LOCAL_CRATE);
+    let cnums = tcx.crates();
 
     let mut instances: DefIdMap<FxHashMap<_, _>> = Default::default();
 

src/librustc_metadata/cstore_impl.rs

@@ -329,7 +329,7 @@ pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
             // which is to say, its not deterministic in general. But
             // we believe that libstd is consistently assigned crate
             // num 1, so it should be enough to resolve #46112.
-            let mut crates: Vec<CrateNum> = (*tcx.crates()).clone();
+            let mut crates = tcx.crates();
             crates.sort();
 
             for &cnum in crates.iter() {

src/librustc_typeck/check/method/suggest.rs

@@ -9,7 +9,7 @@ use errors::{Applicability, DiagnosticBuilder};
 use rustc_data_structures::sync::Lrc;
 use rustc::hir::{self, ExprKind, Node, QPath};
 use rustc::hir::def::Def;
-use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, CrateNum, DefId};
+use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, DefId};
 use rustc::hir::map as hir_map;
 use rustc::hir::print;
 use rustc::infer::type_variable::TypeVariableOrigin;
@@ -775,29 +775,19 @@ fn compute_all_traits<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Vec<DefId>
         }
     }
 
-    let mut cnums: FxHashSet<CrateNum> = FxHashSet::default();
-
     // Attempt to load all crates that we have `--extern` flags for, this means
     // we will be able to make suggestions for traits they define. Particularly useful
     // in Rust 2018 as there aren't `extern crate` lines that import a crate even if it isn't
     // otherwise used.
     for name in tcx.extern_prelude.keys() {
         let cnum = tcx.maybe_load_extern_crate(*name);
         debug!("compute_all_traits: (attempt load) name={:?} cnum={:?}", name, cnum);
-        if let Some(cnum) = cnum {
-            let _ = cnums.insert(cnum);
-        }
-    }
-
-    // Add all crates that we already know about.
-    for &cnum in tcx.crates().iter() {
-        let _ = cnums.insert(cnum);
     }
 
-    for cnum in cnums {
-        debug!("compute_all_traits: cnum={:?} name={:?}", cnum, tcx.crate_name(cnum));
+    for cnum in tcx.crates().iter() {
+        debug!("compute_all_traits: cnum={:?} name={:?}", cnum, tcx.crate_name(*cnum));
         let def_id = DefId {
-            krate: cnum,
+            krate: *cnum,
             index: CRATE_DEF_INDEX,
         };
         handle_external_def(tcx, &mut traits, &mut external_mods, Def::Mod(def_id));

src/test/ui/rust-2018/trait-import-suggestions.stderr

@@ -25,6 +25,12 @@ error[E0599]: no method named `extern_baz` found for type `u32` in the current s
    |
 LL |     x.extern_baz(); //~ ERROR no method named `extern_baz`
    |       ^^^^^^^^^^
+   |
+   = help: items from traits can only be used if the trait is in scope
+help: the following trait is implemented but not in scope, perhaps add a `use` for it:
+   |
+LL | use baz::BazTrait;
+   |
 
 error[E0599]: no function or associated item named `from_str` found for type `u32` in the current scope
   --> $DIR/trait-import-suggestions.rs:33:18