use LocalDefId instead of HirId in trait resolution to simplify the obligation clause resolution

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -766,7 +766,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  let copy_did = infcx.tcx.require_lang_item(LangItem::Copy, Some(span));
  let cause = ObligationCause::new(
  span,
- self.mir_hir_id(),
+ self.mir_def_id(),
  rustc_infer::traits::ObligationCauseCode::MiscObligation,
  );
  let errors = rustc_trait_selection::traits::fully_solve_bound(

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -7,7 +7,6 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::graph::scc::Sccs;
 use rustc_errors::Diagnostic;
 use rustc_hir::def_id::CRATE_DEF_ID;
-use rustc_hir::CRATE_HIR_ID;
 use rustc_index::vec::IndexVec;
 use rustc_infer::infer::outlives::test_type_match;
 use rustc_infer::infer::region_constraints::{GenericKind, VarInfos, VerifyBound, VerifyIfEq};
@@ -2022,7 +2021,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  .map(|constraint| BlameConstraint {
  category: constraint.category,
  from_closure: constraint.from_closure,
- cause: ObligationCause::new(constraint.span, CRATE_HIR_ID, cause_code.clone()),
+ cause: ObligationCause::new(constraint.span, CRATE_DEF_ID, cause_code.clone()),
  variance_info: constraint.variance_info,
  outlives_constraint: *constraint,
  })

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -273,7 +273,6 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
  // This logic duplicates most of `check_opaque_meets_bounds`.
  // FIXME(oli-obk): Also do region checks here and then consider removing `check_opaque_meets_bounds` entirely.
  let param_env = self.tcx.param_env(def_id);
- let body_id = self.tcx.local_def_id_to_hir_id(def_id);
  // HACK This bubble is required for this tests to pass:
  // type-alias-impl-trait/issue-67844-nested-opaque.rs
  let infcx =
@@ -290,15 +289,15 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
  // the bounds that the function supplies.
  let opaque_ty = self.tcx.mk_opaque(def_id.to_def_id(), id_substs);
  if let Err(err) = ocx.eq(
- &ObligationCause::misc(instantiated_ty.span, body_id),
+ &ObligationCause::misc(instantiated_ty.span, def_id),
  param_env,
  opaque_ty,
  definition_ty,
  ) {
  infcx
  .err_ctxt()
  .report_mismatched_types(
- &ObligationCause::misc(instantiated_ty.span, body_id),
+ &ObligationCause::misc(instantiated_ty.span, def_id),
  opaque_ty,
  definition_ty,
  err,
@@ -309,7 +308,7 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
  ocx.register_obligation(Obligation::misc(
  infcx.tcx,
  instantiated_ty.span,
- body_id,
+ def_id,
  param_env,
  predicate,
  ));

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -754,12 +754,9 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  let ocx = ObligationCtxt::new(&infcx);
 
  let predicates = tcx.predicates_of(callee).instantiate(tcx, substs);
- let hir_id = tcx
- .hir()
- .local_def_id_to_hir_id(self.body.source.def_id().expect_local());
  let cause = ObligationCause::new(
  terminator.source_info.span,
- hir_id,
+ self.body.source.def_id().expect_local(),
  ObligationCauseCode::ItemObligation(callee),
  );
  let normalized_predicates = ocx.normalize(&cause, param_env, predicates);

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -2,11 +2,11 @@ use crate::errors::AutoDerefReachedRecursionLimit;
 use crate::traits::query::evaluate_obligation::InferCtxtExt;
 use crate::traits::NormalizeExt;
 use crate::traits::{self, TraitEngine, TraitEngineExt};
-use rustc_hir as hir;
 use rustc_infer::infer::InferCtxt;
 use rustc_middle::ty::TypeVisitable;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::Limit;
+use rustc_span::def_id::LocalDefId;
 use rustc_span::def_id::LOCAL_CRATE;
 use rustc_span::Span;
 
@@ -28,7 +28,7 @@ pub struct Autoderef<'a, 'tcx> {
  // Meta infos:
  infcx: &'a InferCtxt<'tcx>,
  span: Span,
- body_id: hir::HirId,
+ body_id: LocalDefId,
  param_env: ty::ParamEnv<'tcx>,
 
  // Current state:
@@ -96,14 +96,14 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
  pub fn new(
  infcx: &'a InferCtxt<'tcx>,
  param_env: ty::ParamEnv<'tcx>,
- body_id: hir::HirId,
+ body_def_id: LocalDefId,
  span: Span,
  base_ty: Ty<'tcx>,
  ) -> Autoderef<'a, 'tcx> {
  Autoderef {
  infcx,
  span,
- body_id,
+ body_id: body_def_id,
  param_env,
  state: AutoderefSnapshot {
  steps: vec![],

compiler/rustc_hir_analysis/src/check/check.rs

@@ -412,7 +412,6 @@ fn check_opaque_meets_bounds<'tcx>(
  span: Span,
  origin: &hir::OpaqueTyOrigin,
 ) {
- let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
  let defining_use_anchor = match *origin {
  hir::OpaqueTyOrigin::FnReturn(did) | hir::OpaqueTyOrigin::AsyncFn(did) => did,
  hir::OpaqueTyOrigin::TyAlias => def_id,
@@ -438,7 +437,7 @@ fn check_opaque_meets_bounds<'tcx>(
  _ => re,
  });
 
- let misc_cause = traits::ObligationCause::misc(span, hir_id);
+ let misc_cause = traits::ObligationCause::misc(span, def_id);
 
  match ocx.eq(&misc_cause, param_env, opaque_ty, hidden_ty) {
  Ok(()) => {}

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -147,12 +147,12 @@ fn compare_method_predicate_entailment<'tcx>(
  //
  // FIXME(@lcnr): remove that after removing `cause.body_id` from
  // obligations.
- let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.expect_local());
+ let impl_m_def_id = impl_m.def_id.expect_local();
  let cause = ObligationCause::new(
  impl_m_span,
- impl_m_hir_id,
+ impl_m_def_id,
  ObligationCauseCode::CompareImplItemObligation {
- impl_item_def_id: impl_m.def_id.expect_local(),
+ impl_item_def_id: impl_m_def_id,
  trait_item_def_id: trait_m.def_id,
  kind: impl_m.kind,
  },
@@ -198,7 +198,7 @@ fn compare_method_predicate_entailment<'tcx>(
  // Construct trait parameter environment and then shift it into the placeholder viewpoint.
  // The key step here is to update the caller_bounds's predicates to be
  // the new hybrid bounds we computed.
- let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_hir_id);
+ let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_def_id);
  let param_env = ty::ParamEnv::new(
  tcx.intern_predicates(&hybrid_preds.predicates),
  Reveal::UserFacing,
@@ -213,14 +213,14 @@ fn compare_method_predicate_entailment<'tcx>(
 
  let impl_m_own_bounds = impl_m_predicates.instantiate_own(tcx, impl_to_placeholder_substs);
  for (predicate, span) in impl_m_own_bounds {
- let normalize_cause = traits::ObligationCause::misc(span, impl_m_hir_id);
+ let normalize_cause = traits::ObligationCause::misc(span, impl_m_def_id);
  let predicate = ocx.normalize(&normalize_cause, param_env, predicate);
 
  let cause = ObligationCause::new(
  span,
- impl_m_hir_id,
+ impl_m_def_id,
  ObligationCauseCode::CompareImplItemObligation {
- impl_item_def_id: impl_m.def_id.expect_local(),
+ impl_item_def_id: impl_m_def_id,
  trait_item_def_id: trait_m.def_id,
  kind: impl_m.kind,
  },
@@ -253,7 +253,7 @@ fn compare_method_predicate_entailment<'tcx>(
  );
  let unnormalized_impl_fty = tcx.mk_fn_ptr(ty::Binder::dummy(unnormalized_impl_sig));
 
- let norm_cause = ObligationCause::misc(impl_m_span, impl_m_hir_id);
+ let norm_cause = ObligationCause::misc(impl_m_span, impl_m_def_id);
  let impl_sig = ocx.normalize(&norm_cause, param_env, unnormalized_impl_sig);
  debug!("compare_impl_method: impl_fty={:?}", impl_sig);
 
@@ -311,6 +311,7 @@ fn compare_method_predicate_entailment<'tcx>(
  if !errors.is_empty() {
  match check_implied_wf {
  CheckImpliedWfMode::Check => {
+ let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m_def_id);
  return compare_method_predicate_entailment(
  tcx,
  impl_m,
@@ -336,7 +337,7 @@ fn compare_method_predicate_entailment<'tcx>(
  let outlives_env = OutlivesEnvironment::with_bounds(
  param_env,
  Some(infcx),
- infcx.implied_bounds_tys(param_env, impl_m_hir_id, wf_tys.clone()),
+ infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys.clone()),
  );
  infcx.process_registered_region_obligations(
  outlives_env.region_bound_pairs(),
@@ -346,6 +347,7 @@ fn compare_method_predicate_entailment<'tcx>(
  if !errors.is_empty() {
  // FIXME(compiler-errors): This can be simplified when IMPLIED_BOUNDS_ENTAILMENT
  // becomes a hard error (i.e. ideally we'd just call `resolve_regions_and_report_errors`
+ let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m_def_id);
  match check_implied_wf {
  CheckImpliedWfMode::Check => {
  return compare_method_predicate_entailment(
@@ -371,7 +373,7 @@ fn compare_method_predicate_entailment<'tcx>(
  }
  CheckImpliedWfMode::Skip => {
  if infcx.tainted_by_errors().is_none() {
- infcx.err_ctxt().report_region_errors(impl_m.def_id.expect_local(), &errors);
+ infcx.err_ctxt().report_region_errors(impl_m_def_id, &errors);
  }
  return Err(tcx
  .sess
@@ -610,13 +612,14 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
 
  let trait_to_impl_substs = impl_trait_ref.substs;
 
- let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.expect_local());
+ let impl_m_def_id = impl_m.def_id.expect_local();
+ let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m_def_id);
  let return_span = tcx.hir().fn_decl_by_hir_id(impl_m_hir_id).unwrap().output.span();
  let cause = ObligationCause::new(
  return_span,
- impl_m_hir_id,
+ impl_m_def_id,
  ObligationCauseCode::CompareImplItemObligation {
- impl_item_def_id: impl_m.def_id.expect_local(),
+ impl_item_def_id: impl_m_def_id,
  trait_item_def_id: trait_m.def_id,
  kind: impl_m.kind,
  },
@@ -633,7 +636,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
  let ocx = ObligationCtxt::new(infcx);
 
  // Normalize the impl signature with fresh variables for lifetime inference.
- let norm_cause = ObligationCause::misc(return_span, impl_m_hir_id);
+ let norm_cause = ObligationCause::misc(return_span, impl_m_def_id);
  let impl_sig = ocx.normalize(
  &norm_cause,
  param_env,
@@ -650,7 +653,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
  // the ImplTraitInTraitCollector, which gathers all of the RPITITs and replaces
  // them with inference variables.
  // We will use these inference variables to collect the hidden types of RPITITs.
- let mut collector = ImplTraitInTraitCollector::new(&ocx, return_span, param_env, impl_m_hir_id);
+ let mut collector = ImplTraitInTraitCollector::new(&ocx, return_span, param_env, impl_m_def_id);
  let unnormalized_trait_sig = tcx
  .liberate_late_bound_regions(
  impl_m.def_id,
@@ -732,12 +735,11 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
  let outlives_environment = OutlivesEnvironment::with_bounds(
  param_env,
  Some(infcx),
- infcx.implied_bounds_tys(param_env, impl_m_hir_id, wf_tys),
+ infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys),
  );
- infcx.err_ctxt().check_region_obligations_and_report_errors(
- impl_m.def_id.expect_local(),
- &outlives_environment,
- )?;
+ infcx
+ .err_ctxt()
+ .check_region_obligations_and_report_errors(impl_m_def_id, &outlives_environment)?;
 
  let mut collected_tys = FxHashMap::default();
  for (def_id, (ty, substs)) in collector.types {
@@ -819,15 +821,15 @@ struct ImplTraitInTraitCollector<'a, 'tcx> {
  types: FxHashMap<DefId, (Ty<'tcx>, ty::SubstsRef<'tcx>)>,
  span: Span,
  param_env: ty::ParamEnv<'tcx>,
- body_id: hir::HirId,
+ body_id: LocalDefId,
 }
 
 impl<'a, 'tcx> ImplTraitInTraitCollector<'a, 'tcx> {
  fn new(
  ocx: &'a ObligationCtxt<'a, 'tcx>,
  span: Span,
  param_env: ty::ParamEnv<'tcx>,
- body_id: hir::HirId,
+ body_id: LocalDefId,
  ) -> Self {
  ImplTraitInTraitCollector { ocx, types: FxHashMap::default(), span, param_env, body_id }
  }
@@ -1671,14 +1673,12 @@ pub(super) fn compare_impl_const_raw(
 
  // Create a parameter environment that represents the implementation's
  // method.
- 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_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,
+ impl_const_item_def,
  ObligationCauseCode::CompareImplItemObligation {
  impl_item_def_id: impl_const_item_def,
  trait_item_def_id: trait_const_item_def,
@@ -1799,7 +1799,7 @@ fn compare_type_predicate_entailment<'tcx>(
  // This `HirId` should be used for the `body_id` field on each
  // `ObligationCause` (and the `FnCtxt`). This is what
  // `regionck_item` expects.
- let impl_ty_hir_id = tcx.hir().local_def_id_to_hir_id(impl_ty.def_id.expect_local());
+ let impl_ty_def_id = impl_ty.def_id.expect_local();
  debug!("compare_type_predicate_entailment: trait_to_impl_substs={:?}", trait_to_impl_substs);
 
  // The predicates declared by the impl definition, the trait and the
@@ -1814,7 +1814,7 @@ fn compare_type_predicate_entailment<'tcx>(
 
  debug!("compare_type_predicate_entailment: bounds={:?}", hybrid_preds);
 
- let normalize_cause = traits::ObligationCause::misc(impl_ty_span, impl_ty_hir_id);
+ let normalize_cause = traits::ObligationCause::misc(impl_ty_span, impl_ty_def_id);
  let param_env = ty::ParamEnv::new(
  tcx.intern_predicates(&hybrid_preds.predicates),
  Reveal::UserFacing,
@@ -1827,12 +1827,12 @@ fn compare_type_predicate_entailment<'tcx>(
  debug!("compare_type_predicate_entailment: caller_bounds={:?}", param_env.caller_bounds());
 
  for (predicate, span) in impl_ty_own_bounds {
- let cause = ObligationCause::misc(span, impl_ty_hir_id);
+ let cause = ObligationCause::misc(span, impl_ty_def_id);
  let predicate = ocx.normalize(&cause, param_env, predicate);
 
  let cause = ObligationCause::new(
  span,
- impl_ty_hir_id,
+ impl_ty_def_id,
  ObligationCauseCode::CompareImplItemObligation {
  impl_item_def_id: impl_ty.def_id.expect_local(),
  trait_item_def_id: trait_ty.def_id,
@@ -2008,7 +2008,7 @@ pub(super) fn check_type_bounds<'tcx>(
  };
  debug!(?normalize_param_env);
 
- let impl_ty_hir_id = tcx.hir().local_def_id_to_hir_id(impl_ty.def_id.expect_local());
+ let impl_ty_def_id = impl_ty.def_id.expect_local();
  let impl_ty_substs = InternalSubsts::identity_for_item(tcx, impl_ty.def_id);
  let rebased_substs = impl_ty_substs.rebase_onto(tcx, container_id, impl_trait_ref.substs);
 
@@ -2020,7 +2020,7 @@ pub(super) fn check_type_bounds<'tcx>(
 
  let normalize_cause = ObligationCause::new(
  impl_ty_span,
- impl_ty_hir_id,
+ impl_ty_def_id,
  ObligationCauseCode::CheckAssociatedTypeBounds {
  impl_item_def_id: impl_ty.def_id.expect_local(),
  trait_item_def_id: trait_ty.def_id,
@@ -2032,7 +2032,7 @@ pub(super) fn check_type_bounds<'tcx>(
  } else {
  traits::BindingObligation(trait_ty.def_id, span)
  };
- ObligationCause::new(impl_ty_span, impl_ty_hir_id, code)
+ ObligationCause::new(impl_ty_span, impl_ty_def_id, code)
  };
 
  let obligations = tcx
@@ -2063,7 +2063,7 @@ pub(super) fn check_type_bounds<'tcx>(
 
  // Finally, resolve all regions. This catches wily misuses of
  // lifetime parameters.
- let implied_bounds = infcx.implied_bounds_tys(param_env, impl_ty_hir_id, assumed_wf_types);
+ let implied_bounds = infcx.implied_bounds_tys(param_env, impl_ty_def_id, assumed_wf_types);
  let outlives_environment =
  OutlivesEnvironment::with_bounds(param_env, Some(&infcx), implied_bounds);
 

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -56,7 +56,8 @@ fn equate_intrinsic_type<'tcx>(
  && gen_count_ok(own_counts.consts, 0, "const")
  {
  let fty = tcx.mk_fn_ptr(sig);
- let cause = ObligationCause::new(it.span, it.hir_id(), ObligationCauseCode::IntrinsicType);
+ let it_def_id = it.owner_id.def_id;
+ let cause = ObligationCause::new(it.span, it_def_id, ObligationCauseCode::IntrinsicType);
  require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(it.owner_id)), fty);
  }
 }