Remove legacy upstream_monomorphization queries

upstream_monomorphizatons required loading all exported symbols of all dependencies whenever any of them changed. This is problematic for large codebases like Zed.

Author: osiewicz

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -1,9 +1,6 @@
-use std::collections::hash_map::Entry::*;
-
 use rustc_abi::{CanonAbi, X86Call};
 use rustc_ast::expand::allocator::{AllocatorKind, NO_ALLOC_SHIM_IS_UNSTABLE, global_fn_name};
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::unord::UnordMap;
 use rustc_hashes::Hash128;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LOCAL_CRATE, LocalDefId};
@@ -397,87 +394,6 @@ fn exported_generic_symbols_provider_local<'tcx>(
     tcx.arena.alloc_from_iter(symbols)
 }
 
-fn upstream_monomorphizations_provider(
-    tcx: TyCtxt<'_>,
-    (): (),
-) -> DefIdMap<UnordMap<GenericArgsRef<'_>, CrateNum>> {
-    let cnums = tcx.crates(());
-
-    let mut instances: DefIdMap<UnordMap<_, _>> = Default::default();
-
-    let drop_glue_fn_def_id = tcx.lang_items().drop_glue_fn();
-    let async_drop_in_place_fn_def_id = tcx.lang_items().async_drop_in_place_fn();
-
-    for &cnum in cnums.iter() {
-        for (exported_symbol, _) in tcx.exported_generic_symbols(cnum).iter() {
-            let (def_id, args) = match *exported_symbol {
-                ExportedSymbol::Generic(def_id, args) => (def_id, args),
-                ExportedSymbol::DropGlue(ty) => {
-                    if let Some(drop_in_place_fn_def_id) = drop_glue_fn_def_id {
-                        (drop_in_place_fn_def_id, tcx.mk_args(&[ty.into()]))
-                    } else {
-                        // `drop_glue` does not exist, don't try to use it.
-                        continue;
-                    }
-                }
-                ExportedSymbol::AsyncDropGlueCtorShim(ty) => {
-                    if let Some(async_drop_in_place_fn_def_id) = async_drop_in_place_fn_def_id {
-                        (async_drop_in_place_fn_def_id, tcx.mk_args(&[ty.into()]))
-                    } else {
-                        continue;
-                    }
-                }
-                ExportedSymbol::AsyncDropGlue(def_id, ty) => (def_id, tcx.mk_args(&[ty.into()])),
-                ExportedSymbol::NonGeneric(..)
-                | ExportedSymbol::ThreadLocalShim(..)
-                | ExportedSymbol::NoDefId(..) => unreachable!("{exported_symbol:?}"),
-            };
-
-            let args_map = instances.entry(def_id).or_default();
-
-            match args_map.entry(args) {
-                Occupied(mut e) => {
-                    // If there are multiple monomorphizations available,
-                    // we select one deterministically.
-                    let other_cnum = *e.get();
-                    if tcx.stable_crate_id(other_cnum) > tcx.stable_crate_id(cnum) {
-                        e.insert(cnum);
-                    }
-                }
-                Vacant(e) => {
-                    e.insert(cnum);
-                }
-            }
-        }
-    }
-
-    instances
-}
-
-fn upstream_monomorphizations_for_provider(
-    tcx: TyCtxt<'_>,
-    def_id: DefId,
-) -> Option<&UnordMap<GenericArgsRef<'_>, CrateNum>> {
-    assert!(!def_id.is_local());
-    tcx.upstream_monomorphizations(()).get(&def_id)
-}
-
-fn upstream_drop_glue_for_provider<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    args: GenericArgsRef<'tcx>,
-) -> Option<CrateNum> {
-    let def_id = tcx.lang_items().drop_glue_fn()?;
-    tcx.upstream_monomorphizations_for(def_id)?.get(&args).cloned()
-}
-
-fn upstream_async_drop_glue_for_provider<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    args: GenericArgsRef<'tcx>,
-) -> Option<CrateNum> {
-    let def_id = tcx.lang_items().async_drop_in_place_fn()?;
-    tcx.upstream_monomorphizations_for(def_id)?.get(&args).cloned()
-}
-
 fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     !tcx.reachable_set(()).contains(&def_id)
 }
@@ -511,17 +427,12 @@ pub(crate) fn provide(providers: &mut Providers) {
     providers.queries.is_reachable_non_generic = is_reachable_non_generic_provider_local;
     providers.queries.exported_non_generic_symbols = exported_non_generic_symbols_provider_local;
     providers.queries.exported_generic_symbols = exported_generic_symbols_provider_local;
-    providers.queries.upstream_monomorphizations = upstream_monomorphizations_provider;
     providers.queries.is_unreachable_local_definition = is_unreachable_local_definition_provider;
-    providers.queries.upstream_drop_glue_for = upstream_drop_glue_for_provider;
-    providers.queries.upstream_async_drop_glue_for = upstream_async_drop_glue_for_provider;
     providers.queries.upstream_monomorphization_hashes = upstream_monomorphization_hashes_provider;
     providers.queries.upstream_monomorphization_for_hash =
         upstream_monomorphization_for_hash_provider;
     providers.queries.wasm_import_module_map = wasm_import_module_map;
     providers.extern_queries.is_reachable_non_generic = is_reachable_non_generic_provider_extern;
-    providers.extern_queries.upstream_monomorphizations_for =
-        upstream_monomorphizations_for_provider;
 }
 
 pub(crate) fn allocator_shim_symbols(

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -772,7 +772,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 stable_order_of_exportable_impls,
                 exported_non_generic_symbols,
                 exported_generic_symbols,
-                 exported_generic_symbol_hashes,
+                exported_generic_symbol_hashes,
                 interpret_alloc_index,
                 tables,
                 syntax_contexts,
@@ -2274,7 +2274,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(exported_symbols.iter().cloned())
     }
 
-
     fn encode_exported_generic_symbol_hashes(
         &mut self,
         exported_symbols: &[(ExportedSymbol<'tcx>, SymbolExportInfo)],

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -279,7 +279,7 @@ pub(crate) struct CrateRoot {
     stable_order_of_exportable_impls: LazyArray<(DefIndex, usize)>,
     exported_non_generic_symbols: LazyArray<(ExportedSymbol<'static>, SymbolExportInfo)>,
     exported_generic_symbols: LazyArray<(ExportedSymbol<'static>, SymbolExportInfo)>,
-   exported_generic_symbol_hashes: LazyValue<ExportedSymbolHashTableRef>,
+    exported_generic_symbol_hashes: LazyValue<ExportedSymbolHashTableRef>,
 
     syntax_contexts: SyntaxContextTable,
     expn_data: ExpnDataTable,

compiler/rustc_middle/src/queries.rs

@@ -61,6 +61,7 @@ use rustc_data_structures::steal::Steal;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::{ErrorGuaranteed, catch_fatal_errors};
+use rustc_hashes::Hash128;
 use rustc_hir as hir;
 use rustc_hir::attrs::{EiiDecl, EiiImpl, StrippedCfgItem};
 use rustc_hir::def::{DefKind, DocLinkResMap};
@@ -69,7 +70,6 @@ use rustc_hir::lang_items::{LangItem, LanguageItems};
 use rustc_hir::{ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
 use rustc_index::IndexVec;
 use rustc_lint_defs::LintId;
-use rustc_hashes::Hash128;
 use rustc_macros::rustc_queries;
 use rustc_session::Limits;
 use rustc_session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
@@ -1939,75 +1939,6 @@ rustc_queries! {
         }
     }
 
-    /// The entire set of monomorphizations the local crate can safely
-    /// link to because they are exported from upstream crates. Do
-    /// not depend on this directly, as its value changes anytime
-    /// a monomorphization gets added or removed in any upstream
-    /// crate. Instead use the narrower `upstream_monomorphizations_for`,
-    /// `upstream_drop_glue_for`, `upstream_async_drop_glue_for`, or,
-    /// even better, `Instance::upstream_monomorphization()`.
-    query upstream_monomorphizations(_: ()) -> &'tcx DefIdMap<UnordMap<GenericArgsRef<'tcx>, CrateNum>> {
-        arena_cache
-        desc { "collecting available upstream monomorphizations" }
-    }
-
-    /// Returns the set of upstream monomorphizations available for the
-    /// generic function identified by the given `def_id`. The query makes
-    /// sure to make a stable selection if the same monomorphization is
-    /// available in multiple upstream crates.
-    ///
-    /// You likely want to call `Instance::upstream_monomorphization()`
-    /// instead of invoking this query directly.
-    query upstream_monomorphizations_for(def_id: DefId)
-        -> Option<&'tcx UnordMap<GenericArgsRef<'tcx>, CrateNum>>
-    {
-        desc {
-            "collecting available upstream monomorphizations for `{}`",
-            tcx.def_path_str(def_id),
-        }
-        separate_provide_extern
-    }
-
-    /// Returns the upstream crate that exports drop-glue for the given
-    /// type (`args` is expected to be a single-item list containing the
-    /// type one wants drop-glue for).
-    ///
-    /// This is a subset of `upstream_monomorphizations_for` in order to
-    /// increase dep-tracking granularity. Otherwise adding or removing any
-    /// type with drop-glue in any upstream crate would invalidate all
-    /// functions calling drop-glue of an upstream type.
-    ///
-    /// You likely want to call `Instance::upstream_monomorphization()`
-    /// instead of invoking this query directly.
-    ///
-    /// NOTE: This query could easily be extended to also support other
-    ///       common functions that have are large set of monomorphizations
-    ///       (like `Clone::clone` for example).
-    query upstream_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
-        desc { "available upstream drop-glue for `{:?}`", args }
-    }
-
-    /// Returns the upstream crate that exports async-drop-glue for
-    /// the given type (`args` is expected to be a single-item list
-    /// containing the type one wants async-drop-glue for).
-    ///
-    /// This is a subset of `upstream_monomorphizations_for` in order
-    /// to increase dep-tracking granularity. Otherwise adding or
-    /// removing any type with async-drop-glue in any upstream crate
-    /// would invalidate all functions calling async-drop-glue of an
-    /// upstream type.
-    ///
-    /// You likely want to call `Instance::upstream_monomorphization()`
-    /// instead of invoking this query directly.
-    ///
-    /// NOTE: This query could easily be extended to also support other
-    ///       common functions that have are large set of monomorphizations
-    ///       (like `Clone::clone` for example).
-    query upstream_async_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
-        desc { "available upstream async-drop-glue for `{:?}`", args }
-    }
-
-
     /// Set of all fingerprints of generic items exported by `cnum`.
     query exported_generic_symbol_hashes(cnum: CrateNum) -> &'tcx [Hash128] {
         desc { "getting exported generic symbol hashes for crate `{}`", cnum }

compiler/rustc_middle/src/ty/instance.rs

@@ -1,7 +1,7 @@
 use std::{assert_matches, fmt};
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::stable_hash::{StableHasher, StableHash};
+use rustc_data_structures::stable_hash::{StableHash, StableHasher};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hashes::Hash128;
 use rustc_hir as hir;
@@ -225,24 +225,24 @@ impl<'tcx> Instance<'tcx> {
 
         match self.def {
             InstanceKind::Item(_)
-             | InstanceKind::DropGlue(_, Some(_))
-             | InstanceKind::AsyncDropGlueCtorShim(_, _) => {
-                 let hash: Hash128 = tcx.with_stable_hashing_context(|mut hcx| {
-                     let mut hasher = StableHasher::new();
-                     self.stable_hash(&mut hcx, &mut hasher);
-                     hasher.finish()
-                 });
-                 let candidates = tcx.upstream_monomorphization_for_hash(hash)?;
-                 // Candidates are sorted by StableCrateId. First verified match wins.
-                 for &cnum in candidates.iter() {
-                     for (sym, _) in tcx.exported_generic_symbols(cnum).iter() {
-                         if sym.to_instance(tcx).as_ref() == Some(self) {
-                             return Some(cnum);
-                         }
-                     }
-                 }
-                 None
-             }
+            | InstanceKind::DropGlue(_, Some(_))
+            | InstanceKind::AsyncDropGlueCtorShim(_, _) => {
+                let hash: Hash128 = tcx.with_stable_hashing_context(|mut hcx| {
+                    let mut hasher = StableHasher::new();
+                    self.stable_hash(&mut hcx, &mut hasher);
+                    hasher.finish()
+                });
+                let candidates = tcx.upstream_monomorphization_for_hash(hash)?;
+                // Candidates are sorted by StableCrateId. First verified match wins.
+                for &cnum in candidates.iter() {
+                    for (sym, _) in tcx.exported_generic_symbols(cnum).iter() {
+                        if sym.to_instance(tcx).as_ref() == Some(self) {
+                            return Some(cnum);
+                        }
+                    }
+                }
+                None
+            }
             InstanceKind::AsyncDropGlue(_, _) => None,
             InstanceKind::FutureDropPollShim(_, _, _) => None,