Localize many method calls

Author: zetanumbers

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -107,7 +107,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             );
 
             return ty::GenericPredicates {
-                parent: Some(tcx.parent(def_id.to_def_id())),
+                parent: Some(tcx.local_parent(def_id).to_def_id()),
                 predicates: tcx.arena.alloc_from_iter(predicates),
             };
         }

compiler/rustc_incremental/src/assert_dep_graph.rs

@@ -107,7 +107,7 @@ struct IfThisChanged<'tcx> {
 
 impl<'tcx> IfThisChanged<'tcx> {
     fn process_attrs(&mut self, def_id: LocalDefId) {
-        let def_path_hash = self.tcx.def_path_hash(def_id.to_def_id());
+        let def_path_hash = self.tcx.local_def_path_hash(def_id);
         let hir_id = self.tcx.local_def_id_to_hir_id(def_id);
         let attrs = self.tcx.hir_attrs(hir_id);
         for attr in attrs {

compiler/rustc_incremental/src/persist/clean.rs

@@ -350,7 +350,7 @@ impl<'tcx> CleanVisitor<'tcx> {
 
     fn check_item(&mut self, item_id: LocalDefId) {
         let item_span = self.tcx.def_span(item_id.to_def_id());
-        let def_path_hash = self.tcx.def_path_hash(item_id.to_def_id());
+        let def_path_hash = self.tcx.local_def_path_hash(item_id);
 
         let Some(clean_attrs) = find_attr!(self.tcx, item_id, RustcClean(attr) => attr) else {
             return;

compiler/rustc_lint/src/default_could_be_derived.rs

@@ -63,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for DefaultCouldBeDerived {
         }
         let hir::ImplItemKind::Fn(_sig, body_id) = impl_item.kind else { return };
         let impl_id = cx.tcx.local_parent(impl_item.owner_id.def_id);
-        if cx.tcx.is_automatically_derived(impl_id.to_def_id()) {
+        if cx.tcx.is_automatically_derived_local(impl_id) {
             // We don't care about what `#[derive(Default)]` produces in this lint.
             return;
         }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -727,7 +727,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     is_stub: false,
                 },
                 extra_filename: tcx.sess.opts.cg.extra_filename.clone(),
-                stable_crate_id: tcx.def_path_hash(LOCAL_CRATE.as_def_id()).stable_crate_id(),
+                stable_crate_id: tcx.stable_crate_id(LOCAL_CRATE),
                 required_panic_strategy: tcx.required_panic_strategy(LOCAL_CRATE),
                 panic_in_drop_strategy: tcx.sess.opts.unstable_opts.panic_in_drop,
                 edition: tcx.sess.edition(),

compiler/rustc_middle/src/dep_graph/dep_node_key.rs

@@ -109,7 +109,7 @@ impl<'tcx> DepNodeKey<'tcx> for LocalDefId {
 
     #[inline(always)]
     fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        self.to_def_id().to_fingerprint(tcx)
+        tcx.local_def_path_hash(*self).0
     }
 
     #[inline(always)]
@@ -207,7 +207,7 @@ impl<'tcx> DepNodeKey<'tcx> for HirId {
     #[inline(always)]
     fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
         let HirId { owner, local_id } = *self;
-        let def_path_hash = tcx.def_path_hash(owner.to_def_id());
+        let def_path_hash = tcx.local_def_path_hash(owner.def_id);
         Fingerprint::new(
             // `owner` is local, so is completely defined by the local hash
             def_path_hash.local_hash(),

compiler/rustc_middle/src/ty/context.rs

@@ -1207,6 +1207,12 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
+    #[inline]
+    pub fn local_def_path_hash(self, def_id: LocalDefId) -> rustc_hir::definitions::DefPathHash {
+        // Accessing the DefPathHash is ok, it is incr. comp. stable.
+        self.definitions_untracked().def_path_hash(def_id)
+    }
+
     #[inline]
     pub fn crate_types(self) -> &'tcx [CrateType] {
         &self.crate_types

compiler/rustc_middle/src/ty/mod.rs

@@ -1411,7 +1411,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
         // Generate a deterministically-derived seed from the item's path hash
         // to allow for cross-crate compilation to actually work
-        let mut field_shuffle_seed = self.def_path_hash(did.to_def_id()).0.to_smaller_hash();
+        let mut field_shuffle_seed = self.local_def_path_hash(did).0.to_smaller_hash();
 
         // If the user defined a custom seed for layout randomization, xor the item's
         // path hash with the user defined seed, this will allowing determinism while
@@ -1988,6 +1988,11 @@ impl<'tcx> TyCtxt<'tcx> {
         find_attr!(self, def_id, AutomaticallyDerived(..))
     }
 
+    /// Check if the given `DefId` is `#\[automatically_derived\]`.
+    pub fn is_automatically_derived_local(self, def_id: LocalDefId) -> bool {
+        find_attr!(self, def_id, AutomaticallyDerived(..))
+    }
+
     /// Looks up the span of `impl_did` if the impl is local; otherwise returns `Err`
     /// with the name of the crate containing the impl.
     pub fn span_of_impl(self, impl_def_id: DefId) -> Result<Span, Symbol> {

compiler/rustc_mir_transform/src/coverage/query.rs

@@ -61,7 +61,7 @@ fn coverage_attr_on(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     //
     // This affects not just the associated items of an impl block, but also
     // any closures and other nested functions within those associated items.
-    if tcx.is_automatically_derived(def_id.to_def_id()) {
+    if tcx.is_automatically_derived_local(def_id) {
         return false;
     }
 

compiler/rustc_passes/src/dead.rs

@@ -380,8 +380,8 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
     /// for discussion).
     fn should_ignore_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) -> bool {
         if let hir::ImplItemImplKind::Trait { .. } = impl_item.impl_kind
-            && let impl_of = self.tcx.parent(impl_item.owner_id.to_def_id())
-            && self.tcx.is_automatically_derived(impl_of)
+            && let impl_of = self.tcx.local_parent(impl_item.owner_id.def_id)
+            && self.tcx.is_automatically_derived_local(impl_of)
             && let trait_ref = self.tcx.impl_trait_ref(impl_of).instantiate_identity()
             && find_attr!(self.tcx, trait_ref.def_id, RustcTrivialFieldReads)
         {