Auto merge of #106696 - kylematsuda:early-binder, r=lcnr

Switch to `EarlyBinder` for `const_param_default` and `impl_trait_ref` queries

Part of the work to close #105779 and implement rust-lang/types-team#78.

Several queries `X` have a `bound_X` variant that wraps the output in `EarlyBinder`. This PR adds `EarlyBinder` to the return type of  `const_param_default` and `impl_trait_ref`, and removes their `bound_X` variants.

r? `@lcnr`

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -511,9 +511,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  return tcx.const_error(ty).into();
  }
  if !infer_args && has_default {
- tcx.bound_const_param_default(param.def_id)
- .subst(tcx, substs.unwrap())
- .into()
+ tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
  } else {
  if infer_args {
  self.astconv.ct_infer(ty, Some(param), self.span).into()
@@ -2068,7 +2066,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  };
 
  self.one_bound_for_assoc_type(
- || traits::supertraits(tcx, ty::Binder::dummy(trait_ref)),
+ || traits::supertraits(tcx, ty::Binder::dummy(trait_ref.subst_identity())),
  || "Self".to_string(),
  assoc_ident,
  span,
@@ -2157,7 +2155,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  .is_accessible_from(self.item_def_id(), tcx)
  && tcx.all_impls(*trait_def_id)
  .any(|impl_def_id| {
- let trait_ref = tcx.bound_impl_trait_ref(impl_def_id);
+ let trait_ref = tcx.impl_trait_ref(impl_def_id);
  trait_ref.map_or(false, |trait_ref| {
  let impl_ = trait_ref.subst(
  tcx,
@@ -2310,7 +2308,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  && tcx.impl_polarity(impl_def_id) != ty::ImplPolarity::Negative
  })
  .filter_map(|impl_def_id| tcx.impl_trait_ref(impl_def_id))
- .map(|impl_| impl_.self_ty())
+ .map(|impl_| impl_.subst_identity().self_ty())
  // We don't care about blanket impls.
  .filter(|self_ty| !self_ty.has_non_region_param())
  .map(|self_ty| tcx.erase_regions(self_ty).to_string())

compiler/rustc_hir_analysis/src/check/check.rs

@@ -540,7 +540,7 @@ fn check_item_type(tcx: TyCtxt<'_>, id: hir::ItemId) {
  tcx,
  it.span,
  it.owner_id.def_id,
- impl_trait_ref,
+ impl_trait_ref.subst_identity(),
  &impl_.items,
  );
  check_on_unimplemented(tcx, it);

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -616,7 +616,8 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
 ) -> Result<&'tcx FxHashMap<DefId, Ty<'tcx>>, ErrorGuaranteed> {
  let impl_m = tcx.opt_associated_item(def_id).unwrap();
  let trait_m = tcx.opt_associated_item(impl_m.trait_item_def_id.unwrap()).unwrap();
- let impl_trait_ref = tcx.impl_trait_ref(impl_m.impl_container(tcx).unwrap()).unwrap();
+ let impl_trait_ref =
+ tcx.impl_trait_ref(impl_m.impl_container(tcx).unwrap()).unwrap().subst_identity();
  let param_env = tcx.param_env(def_id);
 
  // First, check a few of the same things as `compare_impl_method`,
@@ -1684,7 +1685,8 @@ pub(super) fn compare_impl_const_raw(
 ) -> 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();
+ let impl_trait_ref =
+ tcx.impl_trait_ref(impl_const_item.container_id(tcx)).unwrap().subst_identity();
  debug!("compare_const_impl(impl_trait_ref={:?})", impl_trait_ref);
 
  let impl_c_span = tcx.def_span(impl_const_item_def.to_def_id());

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -182,7 +182,7 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) {
  hir::ItemKind::Impl(ref impl_) => {
  let is_auto = tcx
  .impl_trait_ref(def_id)
- .map_or(false, |trait_ref| tcx.trait_is_auto(trait_ref.def_id));
+ .map_or(false, |trait_ref| tcx.trait_is_auto(trait_ref.skip_binder().def_id));
  if let (hir::Defaultness::Default { .. }, true) = (impl_.defaultness, is_auto) {
  let sp = impl_.of_trait.as_ref().map_or(item.span, |t| t.path.span);
  let mut err =
@@ -1253,7 +1253,7 @@ fn check_impl<'tcx>(
  // `#[rustc_reservation_impl]` impls are not real impls and
  // therefore don't need to be WF (the trait's `Self: Trait` predicate
  // won't hold).
- let trait_ref = tcx.impl_trait_ref(item.owner_id).unwrap();
+ let trait_ref = tcx.impl_trait_ref(item.owner_id).unwrap().subst_identity();
  let trait_ref = wfcx.normalize(
  ast_trait_ref.path.span,
  Some(WellFormedLoc::Ty(item.hir_id().expect_owner().def_id)),
@@ -1350,7 +1350,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
  // is incorrect when dealing with unused substs, for example
  // for `struct Foo<const N: usize, const M: usize = { 1 - 2 }>`
  // we should eagerly error.
- let default_ct = tcx.const_param_default(param.def_id);
+ let default_ct = tcx.const_param_default(param.def_id).subst_identity();
  if !default_ct.needs_subst() {
  wfcx.register_wf_obligation(
  tcx.def_span(param.def_id),
@@ -1396,7 +1396,7 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
  GenericParamDefKind::Const { .. } => {
  // If the param has a default, ...
  if is_our_default(param) {
- let default_ct = tcx.const_param_default(param.def_id);
+ let default_ct = tcx.const_param_default(param.def_id).subst_identity();
  // ... and it's not a dependent default, ...
  if !default_ct.needs_subst() {
  // ... then substitute it with the default.

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -192,7 +192,7 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef
  let source = tcx.type_of(impl_did);
  assert!(!source.has_escaping_bound_vars());
  let target = {
- let trait_ref = tcx.impl_trait_ref(impl_did).unwrap();
+ let trait_ref = tcx.impl_trait_ref(impl_did).unwrap().subst_identity();
  assert_eq!(trait_ref.def_id, dispatch_from_dyn_trait);
 
  trait_ref.substs.type_at(1)
@@ -354,7 +354,7 @@ pub fn coerce_unsized_info<'tcx>(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUn
  });
 
  let source = tcx.type_of(impl_did);
- let trait_ref = tcx.impl_trait_ref(impl_did).unwrap();
+ let trait_ref = tcx.impl_trait_ref(impl_did).unwrap().subst_identity();
  assert_eq!(trait_ref.def_id, coerce_unsized_trait);
  let target = trait_ref.substs.type_at(1);
  debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (bound)", source, target);

compiler/rustc_hir_analysis/src/coherence/mod.rs

@@ -128,7 +128,7 @@ fn coherent_trait(tcx: TyCtxt<'_>, def_id: DefId) {
 
  let impls = tcx.hir().trait_impls(def_id);
  for &impl_def_id in impls {
- let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();
+ let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().subst_identity();
 
  check_impl(tcx, impl_def_id, trait_ref);
  check_object_overlap(tcx, impl_def_id, trait_ref);

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -21,7 +21,7 @@ pub(crate) fn orphan_check_impl(
  tcx: TyCtxt<'_>,
  impl_def_id: LocalDefId,
 ) -> Result<(), ErrorGuaranteed> {
- let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();
+ let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().subst_identity();
  trait_ref.error_reported()?;
 
  let ret = do_orphan_check_impl(tcx, trait_ref, impl_def_id);

compiler/rustc_hir_analysis/src/coherence/unsafety.rs

@@ -14,6 +14,7 @@ pub(super) fn check_item(tcx: TyCtxt<'_>, def_id: LocalDefId) {
  let hir::ItemKind::Impl(ref impl_) = item.kind else { bug!() };
 
  if let Some(trait_ref) = tcx.impl_trait_ref(item.owner_id) {
+ let trait_ref = trait_ref.subst_identity();
  let trait_def = tcx.trait_def(trait_ref.def_id);
  let unsafe_attr =
  impl_.generics.params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle");

compiler/rustc_hir_analysis/src/collect.rs

@@ -1339,18 +1339,22 @@ fn suggest_impl_trait<'tcx>(
  None
 }
 
-fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::TraitRef<'_>> {
+fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::EarlyBinder<ty::TraitRef<'_>>> {
  let icx = ItemCtxt::new(tcx, def_id);
  let item = tcx.hir().expect_item(def_id.expect_local());
  match item.kind {
- hir::ItemKind::Impl(ref impl_) => impl_.of_trait.as_ref().map(|ast_trait_ref| {
- let selfty = tcx.type_of(def_id);
- icx.astconv().instantiate_mono_trait_ref(
- ast_trait_ref,
- selfty,
- check_impl_constness(tcx, impl_.constness, ast_trait_ref),
- )
- }),
+ hir::ItemKind::Impl(ref impl_) => impl_
+ .of_trait
+ .as_ref()
+ .map(|ast_trait_ref| {
+ let selfty = tcx.type_of(def_id);
+ icx.astconv().instantiate_mono_trait_ref(
+ ast_trait_ref,
+ selfty,
+ check_impl_constness(tcx, impl_.constness, ast_trait_ref),
+ )
+ })
+ .map(ty::EarlyBinder),
  _ => bug!(),
  }
 }

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -87,7 +87,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
  Node::Item(item) => match item.kind {
  ItemKind::Impl(ref impl_) => {
  if impl_.defaultness.is_default() {
- is_default_impl_trait = tcx.impl_trait_ref(def_id).map(ty::Binder::dummy);
+ is_default_impl_trait =
+ tcx.impl_trait_ref(def_id).map(|t| ty::Binder::dummy(t.subst_identity()));
  }
  &impl_.generics
  }
@@ -251,7 +252,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
  // for details.
  if let Node::Item(&Item { kind: ItemKind::Impl { .. }, .. }) = node {
  let self_ty = tcx.type_of(def_id);
- let trait_ref = tcx.impl_trait_ref(def_id);
+ let trait_ref = tcx.impl_trait_ref(def_id).map(ty::EarlyBinder::subst_identity);
  cgp::setup_constraining_predicates(
  tcx,
  &mut predicates,

compiler/rustc_hir_analysis/src/impl_wf_check.rs

@@ -85,7 +85,7 @@ fn enforce_impl_params_are_constrained(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
  }
  let impl_generics = tcx.generics_of(impl_def_id);
  let impl_predicates = tcx.predicates_of(impl_def_id);
- let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);
+ let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).map(ty::EarlyBinder::subst_identity);
 
  let mut input_parameters = cgp::parameters_for_impl(impl_self_ty, impl_trait_ref);
  cgp::identify_constrained_generic_params(

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -90,7 +90,7 @@ pub(super) fn check_min_specialization(tcx: TyCtxt<'_>, impl_def_id: LocalDefId)
 
 fn parent_specialization_node(tcx: TyCtxt<'_>, impl1_def_id: LocalDefId) -> Option<Node> {
  let trait_ref = tcx.impl_trait_ref(impl1_def_id)?;
- let trait_def = tcx.trait_def(trait_ref.def_id);
+ let trait_def = tcx.trait_def(trait_ref.skip_binder().def_id);
 
  let impl2_node = trait_def.ancestors(tcx, impl1_def_id.to_def_id()).ok()?.nth(1)?;
 
@@ -207,7 +207,7 @@ fn unconstrained_parent_impl_substs<'tcx>(
  let impl_generic_predicates = tcx.predicates_of(impl_def_id);
  let mut unconstrained_parameters = FxHashSet::default();
  let mut constrained_params = FxHashSet::default();
- let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);
+ let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).map(ty::EarlyBinder::subst_identity);
 
  // Unfortunately the functions in `constrained_generic_parameters` don't do
  // what we want here. We want only a list of constrained parameters while
@@ -370,7 +370,7 @@ fn check_predicates<'tcx>(
  });
 
  // Include the well-formed predicates of the type parameters of the impl.
- for arg in tcx.impl_trait_ref(impl1_def_id).unwrap().substs {
+ for arg in tcx.impl_trait_ref(impl1_def_id).unwrap().subst_identity().substs {
  let infcx = &tcx.infer_ctxt().build();
  let obligations = wf::obligations(
  infcx,

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1224,9 +1224,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
  GenericParamDefKind::Const { has_default } => {
  if !infer_args && has_default {
- tcx.bound_const_param_default(param.def_id)
- .subst(tcx, substs.unwrap())
- .into()
+ tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
  } else {
  self.fcx.var_for_def(self.span, param)
  }

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1072,7 +1072,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // the impl, if local to crate (item may be defaulted), else nothing.
  let Some(item) = self.associated_value(impl_did, item_name).or_else(|| {
  let impl_trait_ref = self.tcx.impl_trait_ref(impl_did)?;
- self.associated_value(impl_trait_ref.def_id, item_name)
+ self.associated_value(impl_trait_ref.skip_binder().def_id, item_name)
  }) else {
  continue;
  };
@@ -1090,7 +1090,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let insertion = match self.tcx.impl_trait_ref(impl_did) {
  None => String::new(),
  Some(trait_ref) => {
- format!(" of the trait `{}`", self.tcx.def_path_str(trait_ref.def_id))
+ format!(
+ " of the trait `{}`",
+ self.tcx.def_path_str(trait_ref.skip_binder().def_id)
+ )
  }
  };
 
@@ -1121,7 +1124,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
  if let Some(sugg_span) = sugg_span
  && let Some(trait_ref) = self.tcx.impl_trait_ref(impl_did) {
- let path = self.tcx.def_path_str(trait_ref.def_id);
+ let path = self.tcx.def_path_str(trait_ref.skip_binder().def_id);
 
  let ty = match item.kind {
  ty::AssocKind::Const | ty::AssocKind::Type => rcvr_ty,
@@ -2616,7 +2619,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  self.tcx.impl_polarity(*imp_did) == ty::ImplPolarity::Negative
  })
  .any(|imp_did| {
- let imp = self.tcx.impl_trait_ref(imp_did).unwrap();
+ let imp = self.tcx.impl_trait_ref(imp_did).unwrap().subst_identity();
  let imp_simp =
  simplify_type(self.tcx, imp.self_ty(), TreatParams::AsPlaceholder);
  imp_simp.map_or(false, |s| s == simp_rcvr_ty)

compiler/rustc_infer/src/infer/error_reporting/note.rs

@@ -320,6 +320,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  .impl_trait_ref(impl_def_id)
  else { return; };
  let trait_substs = trait_ref
+ .subst_identity()
  // Replace the explicit self type with `Self` for better suggestion rendering
  .with_self_ty(self.tcx, self.tcx.mk_ty_param(0, kw::SelfUpper))
  .substs;

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1555,7 +1555,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  self.tables.impl_defaultness.set(def_id.index, *defaultness);
  self.tables.constness.set(def_id.index, *constness);
 
- let trait_ref = self.tcx.impl_trait_ref(def_id);
+ let trait_ref = self.tcx.impl_trait_ref(def_id).map(ty::EarlyBinder::skip_binder);
  if let Some(trait_ref) = trait_ref {
  let trait_def = self.tcx.trait_def(trait_ref.def_id);
  if let Ok(mut an) = trait_def.ancestors(self.tcx, def_id) {
@@ -1899,6 +1899,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  for id in tcx.hir().items() {
  if matches!(tcx.def_kind(id.owner_id), DefKind::Impl) {
  if let Some(trait_ref) = tcx.impl_trait_ref(id.owner_id) {
+ let trait_ref = trait_ref.subst_identity();
+
  let simplified_self_ty = fast_reject::simplify_type(
  self.tcx,
  trait_ref.self_ty(),

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -359,8 +359,8 @@ define_tables! {
  variances_of: Table<DefIndex, LazyArray<ty::Variance>>,
  fn_sig: Table<DefIndex, LazyValue<ty::PolyFnSig<'static>>>,
  codegen_fn_attrs: Table<DefIndex, LazyValue<CodegenFnAttrs>>,
- impl_trait_ref: Table<DefIndex, LazyValue<ty::TraitRef<'static>>>,
- const_param_default: Table<DefIndex, LazyValue<rustc_middle::ty::Const<'static>>>,
+ impl_trait_ref: Table<DefIndex, LazyValue<ty::EarlyBinder<ty::TraitRef<'static>>>>,
+ const_param_default: Table<DefIndex, LazyValue<ty::EarlyBinder<rustc_middle::ty::Const<'static>>>>,
  object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>,
  optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>,
  mir_for_ctfe: Table<DefIndex, LazyValue<mir::Body<'static>>>,

compiler/rustc_middle/src/hir/mod.rs

@@ -102,6 +102,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
  pub fn impl_subject(self, def_id: DefId) -> ImplSubject<'tcx> {
  self.impl_trait_ref(def_id)
+ .map(|t| t.subst_identity())
  .map(ImplSubject::Trait)
  .unwrap_or_else(|| ImplSubject::Inherent(self.type_of(def_id)))
  }

compiler/rustc_middle/src/query/mod.rs

@@ -142,7 +142,7 @@ rustc_queries! {
 
  /// Given the def_id of a const-generic parameter, computes the associated default const
  /// parameter. e.g. `fn example<const N: usize=3>` called on `N` would return `3`.
- query const_param_default(param: DefId) -> ty::Const<'tcx> {
+ query const_param_default(param: DefId) -> ty::EarlyBinder<ty::Const<'tcx>> {
  desc { |tcx| "computing const default for a given parameter `{}`", tcx.def_path_str(param) }
  cache_on_disk_if { param.is_local() }
  separate_provide_extern
@@ -737,7 +737,7 @@ rustc_queries! {
 
  /// Given an `impl_id`, return the trait it implements.
  /// Return `None` if this is an inherent impl.
- query impl_trait_ref(impl_id: DefId) -> Option<ty::TraitRef<'tcx>> {
+ query impl_trait_ref(impl_id: DefId) -> Option<ty::EarlyBinder<ty::TraitRef<'tcx>>> {
  desc { |tcx| "computing trait implemented by `{}`", tcx.def_path_str(impl_id) }
  cache_on_disk_if { impl_id.is_local() }
  separate_provide_extern

compiler/rustc_middle/src/ty/consts.rs

@@ -239,7 +239,7 @@ impl<'tcx> Const<'tcx> {
  }
 }
 
-pub fn const_param_default(tcx: TyCtxt<'_>, def_id: DefId) -> Const<'_> {
+pub fn const_param_default(tcx: TyCtxt<'_>, def_id: DefId) -> ty::EarlyBinder<Const<'_>> {
  let default_def_id = match tcx.hir().get_by_def_id(def_id.expect_local()) {
  hir::Node::GenericParam(hir::GenericParam {
  kind: hir::GenericParamKind::Const { default: Some(ac), .. },
@@ -250,5 +250,5 @@ pub fn const_param_default(tcx: TyCtxt<'_>, def_id: DefId) -> Const<'_> {
  "`const_param_default` expected a generic parameter with a constant"
  ),
  };
- Const::from_anon_const(tcx, default_def_id)
+ ty::EarlyBinder(Const::from_anon_const(tcx, default_def_id))
 }

compiler/rustc_middle/src/ty/generics.rs

@@ -88,7 +88,7 @@ impl GenericParamDef {
  Some(tcx.bound_type_of(self.def_id).map_bound(|t| t.into()))
  }
  GenericParamDefKind::Const { has_default } if has_default => {
- Some(tcx.bound_const_param_default(self.def_id).map_bound(|c| c.into()))
+ Some(tcx.const_param_default(self.def_id).map_bound(|c| c.into()))
  }
  _ => None,
  }