make query take (LocalDefId, DefId)

Author: BoxyUwU

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1046,9 +1046,8 @@ fn check_impl_items_against_trait<'tcx>(
             hir::ImplItemKind::Const(..) => {
                 // Find associated const definition.
                 let _ = tcx.compare_assoc_const_impl_item_with_trait_item((
-                    &ty_impl_item,
-                    &ty_trait_item,
-                    impl_trait_ref,
+                    impl_item.id.def_id.def_id,
+                    ty_impl_item.trait_item_def_id.unwrap(),
                 ));
             }
             hir::ImplItemKind::Fn(..) => {

compiler/rustc_hir_analysis/src/check/compare_method.rs

@@ -1,6 +1,6 @@
 use super::potentially_plural_count;
 use crate::errors::LifetimesOrBoundsMismatchOnTrait;
-use hir::def_id::DefId;
+use hir::def_id::{DefId, LocalDefId};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticId, ErrorGuaranteed};
 use rustc_hir as hir;
@@ -1303,14 +1303,17 @@ fn compare_generic_param_kinds<'tcx>(
 /// Use `tcx.compare_assoc_const_impl_item_with_trait_item` instead
 pub(crate) fn raw_compare_const_impl<'tcx>(
     tcx: TyCtxt<'tcx>,
-    (impl_c, trait_c, impl_trait_ref): (&ty::AssocItem, &ty::AssocItem, ty::TraitRef<'tcx>),
+    (impl_const_item_def, trait_const_item_def): (LocalDefId, DefId),
 ) -> Result<(), ErrorGuaranteed> {
+    let impl_const_item = tcx.associated_item(impl_const_item_def);
+    let trait_const_item = tcx.associated_item(trait_const_item_def);
+    let impl_trait_ref = tcx.impl_trait_ref(impl_const_item.container_id(tcx)).unwrap();
     debug!("compare_const_impl(impl_trait_ref={:?})", impl_trait_ref);
 
-    let impl_c_span = tcx.def_span(impl_c.def_id);
+    let impl_c_span = tcx.def_span(impl_const_item_def.to_def_id());
 
     tcx.infer_ctxt().enter(|infcx| {
-        let param_env = tcx.param_env(impl_c.def_id);
+        let param_env = tcx.param_env(impl_const_item_def.to_def_id());
         let ocx = ObligationCtxt::new(&infcx);
 
         // The below is for the most part highly similar to the procedure
@@ -1322,18 +1325,18 @@ pub(crate) fn raw_compare_const_impl<'tcx>(
 
         // Create a parameter environment that represents the implementation's
         // method.
-        let impl_c_hir_id = tcx.hir().local_def_id_to_hir_id(impl_c.def_id.expect_local());
+        let impl_c_hir_id = tcx.hir().local_def_id_to_hir_id(impl_const_item_def);
 
         // Compute placeholder form of impl and trait const tys.
-        let impl_ty = tcx.type_of(impl_c.def_id);
-        let trait_ty = tcx.bound_type_of(trait_c.def_id).subst(tcx, trait_to_impl_substs);
+        let impl_ty = tcx.type_of(impl_const_item_def.to_def_id());
+        let trait_ty = tcx.bound_type_of(trait_const_item_def).subst(tcx, trait_to_impl_substs);
         let mut cause = ObligationCause::new(
             impl_c_span,
             impl_c_hir_id,
             ObligationCauseCode::CompareImplItemObligation {
-                impl_item_def_id: impl_c.def_id.expect_local(),
-                trait_item_def_id: trait_c.def_id,
-                kind: impl_c.kind,
+                impl_item_def_id: impl_const_item_def,
+                trait_item_def_id: trait_const_item_def,
+                kind: impl_const_item.kind,
             },
         );
 
@@ -1357,24 +1360,24 @@ pub(crate) fn raw_compare_const_impl<'tcx>(
                 );
 
                 // Locate the Span containing just the type of the offending impl
-                match tcx.hir().expect_impl_item(impl_c.def_id.expect_local()).kind {
+                match tcx.hir().expect_impl_item(impl_const_item_def).kind {
                     ImplItemKind::Const(ref ty, _) => cause.span = ty.span,
-                    _ => bug!("{:?} is not a impl const", impl_c),
+                    _ => bug!("{:?} is not a impl const", impl_const_item),
                 }
 
                 let mut diag = struct_span_err!(
                     tcx.sess,
                     cause.span,
                     E0326,
                     "implemented const `{}` has an incompatible type for trait",
-                    trait_c.name
+                    trait_const_item.name
                 );
 
-                let trait_c_span = trait_c.def_id.as_local().map(|trait_c_def_id| {
+                let trait_c_span = trait_const_item_def.as_local().map(|trait_c_def_id| {
                     // Add a label to the Span containing just the type of the const
                     match tcx.hir().expect_trait_item(trait_c_def_id).kind {
                         TraitItemKind::Const(ref ty, _) => ty.span,
-                        _ => bug!("{:?} is not a trait const", trait_c),
+                        _ => bug!("{:?} is not a trait const", trait_const_item),
                     }
                 });
 
@@ -1402,10 +1405,8 @@ pub(crate) fn raw_compare_const_impl<'tcx>(
 
         // FIXME return `ErrorReported` if region obligations error?
         let outlives_environment = OutlivesEnvironment::new(param_env);
-        infcx.check_region_obligations_and_report_errors(
-            impl_c.def_id.expect_local(),
-            &outlives_environment,
-        );
+        infcx
+            .check_region_obligations_and_report_errors(impl_const_item_def, &outlives_environment);
         maybe_error_reported
     })
 }

compiler/rustc_middle/src/query/mod.rs

@@ -2102,8 +2102,8 @@ rustc_queries! {
     }
 
     query compare_assoc_const_impl_item_with_trait_item(
-        key: (&'tcx ty::AssocItem, &'tcx ty::AssocItem, ty::TraitRef<'tcx>)
+        key: (LocalDefId, DefId)
     ) -> Result<(), ErrorGuaranteed> {
-        desc { |tcx| "checking assoc const `{}` has the same type as trait item", tcx.def_path_str(key.0.def_id) }
+        desc { |tcx| "checking assoc const `{}` has the same type as trait item", tcx.def_path_str(key.0.to_def_id()) }
     }
 }

compiler/rustc_ty_utils/src/instance.rs

@@ -184,15 +184,11 @@ fn resolve_associated_item<'tcx>(
             // error has already been/will be emitted elsewhere).
             if leaf_def.item.kind == ty::AssocKind::Const
                 && trait_item_id != leaf_def.item.def_id
-                && leaf_def.item.def_id.is_local()
+                && let Some(leaf_def_item) = leaf_def.item.def_id.as_local()
             {
-                let impl_item = tcx.associated_item(leaf_def.item.def_id);
-                let trait_item = tcx.associated_item(trait_item_id);
-                let impl_trait_ref = tcx.impl_trait_ref(impl_item.container_id(tcx)).unwrap();
                 tcx.compare_assoc_const_impl_item_with_trait_item((
-                    impl_item,
-                    trait_item,
-                    impl_trait_ref,
+                    leaf_def_item,
+                    trait_item_id,
                 ))?;
             }
 

compiler/rustc_ty_utils/src/lib.rs

@@ -5,6 +5,7 @@
 //! This API is completely unstable and subject to change.
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
+#![feature(let_chains)]
 #![feature(control_flow_enum)]
 #![feature(never_type)]
 #![feature(box_patterns)]