rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Split impl_(opt_)trait_ref

Browse Source
This commit is contained in:
Cameron Steffen
2025-10-13 12:56:21 -05:00
parent ae8ff943c1
commit e60e9f0826
41 changed files with 95 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_hir_analysis/src/check/always_applicable.rs
View File

@@ -210,8 +210,7 @@ fn ensure_impl_predicates_are_implied_by_item_defn<'tcx>(
ty::EarlyBinder::bind(tcx.param_env(adt_def_id)).instantiate(tcx, adt_to_impl_args);
let fresh_impl_args = infcx.fresh_args_for_item(impl_span, impl_def_id.to_def_id());
let fresh_adt_ty =
tcx.impl_trait_ref(impl_def_id).unwrap().instantiate(tcx, fresh_impl_args).self_ty();
let fresh_adt_ty = tcx.impl_trait_ref(impl_def_id).instantiate(tcx, fresh_impl_args).self_ty();
ocx.eq(&ObligationCause::dummy_with_span(impl_span), adt_env, fresh_adt_ty, impl_adt_ty)
.expect("equating fully generic trait ref should never fail");

4
compiler/rustc_hir_analysis/src/check/check.rs
View File

@@ -1191,9 +1191,7 @@ fn check_impl_items_against_trait<'tcx>(
tcx,
ty_impl_item,
ty_trait_item,
tcx.impl_trait_ref(ty_impl_item.container_id(tcx))
.unwrap()
.instantiate_identity(),
tcx.impl_trait_ref(ty_impl_item.container_id(tcx)).instantiate_identity(),
);
}
ty::AssocKind::Const { .. } => {}

5
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View File

@@ -38,8 +38,7 @@ pub(super) fn compare_impl_item(
) -> Result<(), ErrorGuaranteed> {
let impl_item = tcx.associated_item(impl_item_def_id);
let trait_item = tcx.associated_item(impl_item.expect_trait_impl()?);
let impl_trait_ref =
tcx.impl_trait_ref(impl_item.container_id(tcx)).unwrap().instantiate_identity();
let impl_trait_ref = tcx.impl_trait_ref(impl_item.container_id(tcx)).instantiate_identity();
debug!(?impl_trait_ref);
match impl_item.kind {
@@ -443,7 +442,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
let impl_m = tcx.associated_item(impl_m_def_id.to_def_id());
let trait_m = tcx.associated_item(impl_m.expect_trait_impl()?);
let impl_trait_ref =
tcx.impl_trait_ref(tcx.parent(impl_m_def_id.to_def_id())).unwrap().instantiate_identity();
tcx.impl_trait_ref(tcx.parent(impl_m_def_id.to_def_id())).instantiate_identity();
// First, check a few of the same things as `compare_impl_method`,
// just so we don't ICE during instantiation later.
check_method_is_structurally_compatible(tcx, impl_m, trait_m, impl_trait_ref, true)?;

2
compiler/rustc_hir_analysis/src/check/mod.rs
View File

@@ -244,7 +244,7 @@ fn missing_items_err(
let snippet = with_types_for_signature!(suggestion_signature(
tcx,
trait_item,
tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity(),
tcx.impl_trait_ref(impl_def_id).instantiate_identity(),
));
let code = format!("{padding}{snippet}\n{padding}");
if let Some(span) = tcx.hir_span_if_local(trait_item.def_id) {

2
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@@ -1258,7 +1258,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().instantiate_identity();
let trait_ref = tcx.impl_trait_ref(item.owner_id).instantiate_identity();
// Avoid bogus "type annotations needed `Foo: Bar`" errors on `impl Bar for Foo` in case
// other `Foo` impls are incoherent.
tcx.ensure_ok().coherent_trait(trait_ref.def_id)?;

4
compiler/rustc_hir_analysis/src/coherence/builtin.rs
View File

@@ -377,7 +377,7 @@ pub(crate) fn coerce_unsized_info<'tcx>(
let unsize_trait = tcx.require_lang_item(LangItem::Unsize, span);
let source = tcx.type_of(impl_did).instantiate_identity();
let trait_ref = tcx.impl_trait_ref(impl_did).unwrap().instantiate_identity();
let trait_ref = tcx.impl_trait_ref(impl_did).instantiate_identity();
assert_eq!(trait_ref.def_id, coerce_unsized_trait);
let target = trait_ref.args.type_at(1);
@@ -707,7 +707,7 @@ fn visit_implementation_of_coerce_pointee_validity(
checker: &Checker<'_>,
) -> Result<(), ErrorGuaranteed> {
let tcx = checker.tcx;
let self_ty = tcx.impl_trait_ref(checker.impl_def_id).unwrap().instantiate_identity().self_ty();
let self_ty = tcx.impl_trait_ref(checker.impl_def_id).instantiate_identity().self_ty();
let span = tcx.def_span(checker.impl_def_id);
if !tcx.is_builtin_derived(checker.impl_def_id.into()) {
return Err(tcx.dcx().emit_err(errors::CoercePointeeNoUserValidityAssertion { span }));

4
compiler/rustc_hir_analysis/src/coherence/orphan.rs
View File

@@ -22,7 +22,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().instantiate_identity();
let trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate_identity();
trait_ref.error_reported()?;
match orphan_check(tcx, impl_def_id, OrphanCheckMode::Proper) {
@@ -294,7 +294,7 @@ fn orphan_check<'tcx>(
) -> Result<(), OrphanCheckErr<TyCtxt<'tcx>, FxIndexSet<DefId>>> {
// We only accept this routine to be invoked on implementations
// of a trait, not inherent implementations.
let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();
let trait_ref = tcx.impl_trait_ref(impl_def_id);
debug!(trait_ref = ?trait_ref.skip_binder());
// If the *trait* is local to the crate, ok.

2
compiler/rustc_hir_analysis/src/collect/dump.rs
View File

@@ -108,7 +108,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
let vtable_entries = match tcx.hir_item(id).kind {
hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => {
let trait_ref = tcx.impl_trait_ref(def_id).unwrap().instantiate_identity();
let trait_ref = tcx.impl_trait_ref(def_id).instantiate_identity();
if trait_ref.has_non_region_param() {
tcx.dcx().span_err(
attr.span(),

16
compiler/rustc_hir_analysis/src/collect/predicates_of.rs
View File

@@ -118,8 +118,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
let impl_assoc_identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
let impl_def_id = tcx.parent(fn_def_id);
let impl_trait_ref_args =
tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity().args;
let impl_trait_ref_args = tcx.impl_trait_ref(impl_def_id).instantiate_identity().args;
let impl_assoc_args =
impl_assoc_identity_args.rebase_onto(tcx, impl_def_id, impl_trait_ref_args);
@@ -162,9 +161,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
if let Some(of_trait) = impl_.of_trait
&& of_trait.defaultness.is_default()
{
is_default_impl_trait = tcx
.impl_trait_ref(def_id)
.map(|t| ty::Binder::dummy(t.instantiate_identity()));
is_default_impl_trait =
Some(ty::Binder::dummy(tcx.impl_trait_ref(def_id).instantiate_identity()));
}
}
ItemKind::Trait(_, _, _, _, _, self_bounds, ..)
@@ -352,10 +350,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
// for details.
if let Node::Item(&Item { kind: ItemKind::Impl(impl_), .. }) = node {
let self_ty = tcx.type_of(def_id).instantiate_identity();
let trait_ref = impl_
.of_trait
.is_some()
.then(|| tcx.impl_trait_ref(def_id).unwrap().instantiate_identity());
let trait_ref =
impl_.of_trait.is_some().then(|| tcx.impl_trait_ref(def_id).instantiate_identity());
cgp::setup_constraining_predicates(
tcx,
&mut predicates,
@@ -467,7 +463,7 @@ fn const_evaluatable_predicates_of<'tcx>(
{
if impl_.of_trait.is_some() {
debug!("visit impl trait_ref");
let trait_ref = tcx.impl_trait_ref(def_id).unwrap();
let trait_ref = tcx.impl_trait_ref(def_id);
trait_ref.instantiate_identity().visit_with(&mut collector);
}

5
compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
View File

@@ -1387,10 +1387,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
(_, Res::SelfTyAlias { alias_to: impl_def_id, is_trait_impl: true, .. }) => {
// `Self` in an impl of a trait -- we have a concrete self type and a
// trait reference.
let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) else {
// A cycle error occurred, most likely.
self.dcx().span_bug(span, "expected cycle error");
};
let trait_ref = tcx.impl_trait_ref(impl_def_id);
self.probe_single_bound_for_assoc_item(
|| {

6
compiler/rustc_hir_analysis/src/impl_wf_check.rs
View File

@@ -85,8 +85,7 @@ pub(crate) fn enforce_impl_lifetime_params_are_constrained(
let impl_generics = tcx.generics_of(impl_def_id);
let impl_predicates = tcx.predicates_of(impl_def_id);
let impl_trait_ref =
of_trait.then(|| tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity());
let impl_trait_ref = of_trait.then(|| tcx.impl_trait_ref(impl_def_id).instantiate_identity());
impl_trait_ref.error_reported()?;
@@ -174,7 +173,8 @@ pub(crate) fn enforce_impl_non_lifetime_params_are_constrained(
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).map(ty::EarlyBinder::instantiate_identity);
let impl_trait_ref =
tcx.impl_opt_trait_ref(impl_def_id).map(ty::EarlyBinder::instantiate_identity);
impl_trait_ref.error_reported()?;

8
compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
View File

@@ -93,7 +93,7 @@ pub(super) fn check_min_specialization(
}
fn parent_specialization_node(tcx: TyCtxt<'_>, impl1_def_id: LocalDefId) -> Option<Node> {
let trait_ref = tcx.impl_trait_ref(impl1_def_id).unwrap();
let trait_ref = tcx.impl_trait_ref(impl1_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)?;
@@ -215,7 +215,7 @@ fn unconstrained_parent_impl_args<'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).map(ty::EarlyBinder::instantiate_identity);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate_identity();
// Unfortunately the functions in `constrained_generic_parameters` don't do
// what we want here. We want only a list of constrained parameters while
@@ -224,7 +224,7 @@ fn unconstrained_parent_impl_args<'tcx>(
for (clause, _) in impl_generic_predicates.predicates.iter() {
if let ty::ClauseKind::Projection(proj) = clause.kind().skip_binder() {
let unbound_trait_ref = proj.projection_term.trait_ref(tcx);
if Some(unbound_trait_ref) == impl_trait_ref {
if unbound_trait_ref == impl_trait_ref {
continue;
}
@@ -373,7 +373,7 @@ fn check_predicates<'tcx>(
.map(|(c, _span)| c.as_predicate());
// Include the well-formed predicates of the type parameters of the impl.
for arg in tcx.impl_trait_ref(impl1_def_id).unwrap().instantiate_identity().args {
for arg in tcx.impl_trait_ref(impl1_def_id).instantiate_identity().args {
let Some(term) = arg.as_term() else {
continue;
};

2
compiler/rustc_hir_typeck/src/expr.rs
View File

@@ -3629,7 +3629,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let ocx = ObligationCtxt::new_with_diagnostics(self);
let impl_args = self.fresh_args_for_item(base_expr.span, impl_def_id);
let impl_trait_ref =
self.tcx.impl_trait_ref(impl_def_id).unwrap().instantiate(self.tcx, impl_args);
self.tcx.impl_trait_ref(impl_def_id).instantiate(self.tcx, impl_args);
let cause = self.misc(base_expr.span);
// Match the impl self type against the base ty. If this fails,

2
compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
View File

@@ -711,7 +711,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
)
} else {
self.tcx
.impl_trait_ref(obligation.impl_or_alias_def_id)
.impl_opt_trait_ref(obligation.impl_or_alias_def_id)
.map(|impl_def| impl_def.skip_binder())
// It is possible that this is absent. In this case, we make no progress.
.ok_or(expr)?

2
compiler/rustc_hir_typeck/src/lib.rs
View File

@@ -285,7 +285,7 @@ fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Opti
&& let ty::AssocContainer::TraitImpl(Ok(trait_item_def_id)) = item.container
{
let impl_def_id = item.container_id(tcx);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity();
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate_identity();
let args = ty::GenericArgs::identity_for_item(tcx, def_id).rebase_onto(
tcx,
impl_def_id,

8
compiler/rustc_hir_typeck/src/method/suggest.rs
View File

@@ -1962,8 +1962,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Provide the best span we can. Use the item, if local to crate, else
// 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.skip_binder().def_id, item_name)
let impl_trait_id = self.tcx.impl_opt_trait_id(impl_did)?;
self.associated_value(impl_trait_id, item_name)
}) else {
continue;
};
@@ -1978,7 +1978,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let impl_ty = self.tcx.at(span).type_of(impl_did).instantiate_identity();
let insertion = match self.tcx.impl_trait_ref(impl_did) {
let insertion = match self.tcx.impl_opt_trait_ref(impl_did) {
None => String::new(),
Some(trait_ref) => {
format!(
@@ -2013,7 +2013,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
err.note(note_str);
}
if let Some(sugg_span) = sugg_span
&& let Some(trait_ref) = self.tcx.impl_trait_ref(impl_did)
&& let Some(trait_ref) = self.tcx.impl_opt_trait_ref(impl_did)
&& let Some(sugg) = print_disambiguation_help(
self.tcx,
err,

2
compiler/rustc_middle/src/ty/context.rs
View File

@@ -679,7 +679,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
}
fn impl_trait_ref(self, impl_def_id: DefId) -> ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>> {
self.impl_trait_ref(impl_def_id).unwrap()
self.impl_trait_ref(impl_def_id)
}
fn impl_polarity(self, impl_def_id: DefId) -> ty::ImplPolarity {

32
compiler/rustc_middle/src/ty/mod.rs
View File

@@ -1937,6 +1937,14 @@ impl<'tcx> TyCtxt<'tcx> {
}
}
pub fn impl_is_of_trait(self, def_id: impl IntoQueryParam<DefId>) -> bool {
let def_id = def_id.into_query_param();
let DefKind::Impl { of_trait } = self.def_kind(def_id) else {
panic!("expected Impl for {def_id:?}");
};
of_trait
}
/// If the given `DefId` is an associated item of an impl,
/// returns the `DefId` of the impl; otherwise returns `None`.
pub fn impl_of_assoc(self, def_id: DefId) -> Option<DefId> {
@@ -1969,24 +1977,32 @@ impl<'tcx> TyCtxt<'tcx> {
}
/// Given an `impl_id`, return the trait it implements.
/// Return `None` if this is an inherent impl.
pub fn impl_trait_ref(
self,
def_id: impl IntoQueryParam<DefId>,
) -> ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>> {
self.impl_opt_trait_ref(def_id).unwrap()
}
/// Given an `impl_id`, return the trait it implements.
/// Returns `None` if it is an inherent impl.
pub fn impl_opt_trait_ref(
self,
def_id: impl IntoQueryParam<DefId>,
) -> Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>> {
Some(self.impl_trait_header(def_id)?.trait_ref)
self.impl_trait_header(def_id).map(|header| header.trait_ref)
}
/// Given the `DefId` of an impl, returns the `DefId` of the trait it implements.
pub fn impl_trait_id(self, def_id: DefId) -> DefId {
self.impl_opt_trait_id(def_id)
.unwrap_or_else(|| panic!("expected impl of trait for {def_id:?}"))
pub fn impl_trait_id(self, def_id: impl IntoQueryParam<DefId>) -> DefId {
self.impl_trait_ref(def_id).skip_binder().def_id
}
/// Given the `DefId` of an impl, returns the `DefId` of the trait it implements.
/// If it implements no trait, returns `None`.
pub fn impl_opt_trait_id(self, def_id: DefId) -> Option<DefId> {
self.impl_trait_ref(def_id).map(|tr| tr.skip_binder().def_id)
/// Returns `None` if it is an inherent impl.
pub fn impl_opt_trait_id(self, def_id: impl IntoQueryParam<DefId>) -> Option<DefId> {
let def_id = def_id.into_query_param();
self.impl_is_of_trait(def_id).then(|| self.impl_trait_id(def_id))
}
pub fn is_exportable(self, def_id: DefId) -> bool {

2
compiler/rustc_middle/src/ty/print/mod.rs
View File

@@ -45,7 +45,7 @@ pub trait Printer<'tcx>: Sized {
) -> Result<(), PrintError> {
let tcx = self.tcx();
let self_ty = tcx.type_of(impl_def_id);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);
let impl_trait_ref = tcx.impl_opt_trait_ref(impl_def_id);
let (self_ty, impl_trait_ref) = if tcx.generics_of(impl_def_id).count() <= args.len() {
(
self_ty.instantiate(tcx, args),

2
compiler/rustc_mir_transform/src/check_call_recursion.rs
View File

@@ -44,7 +44,7 @@ impl<'tcx> MirLint<'tcx> for CheckDropRecursion {
// First check if `body` is an `fn drop()` of `Drop`
if let DefKind::AssocFn = tcx.def_kind(def_id)
&& let Some(impl_id) = tcx.trait_impl_of_assoc(def_id.to_def_id())
&& let trait_ref = tcx.impl_trait_ref(impl_id).unwrap()
&& let trait_ref = tcx.impl_trait_ref(impl_id)
&& tcx.is_lang_item(trait_ref.instantiate_identity().def_id, LangItem::Drop)
// avoid erroneous `Drop` impls from causing ICEs below
&& let sig = tcx.fn_sig(def_id).instantiate_identity()

11
compiler/rustc_passes/src/dead.rs
View File

@@ -377,7 +377,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
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 trait_ref = self.tcx.impl_trait_ref(impl_of).unwrap().instantiate_identity()
&& let trait_ref = self.tcx.impl_trait_ref(impl_of).instantiate_identity()
&& self.tcx.has_attr(trait_ref.def_id, sym::rustc_trivial_field_reads)
{
if let ty::Adt(adt_def, _) = trait_ref.self_ty().kind()
@@ -486,12 +486,9 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
(self.tcx.local_parent(local_def_id), trait_item_id)
}
// impl items are live if the corresponding traits are live
DefKind::Impl { of_trait: true } => (
local_def_id,
self.tcx
.impl_trait_ref(local_def_id)
.and_then(|trait_ref| trait_ref.skip_binder().def_id.as_local()),
),
DefKind::Impl { of_trait: true } => {
(local_def_id, self.tcx.impl_trait_id(local_def_id).as_local())
}
_ => bug!(),
};

11
compiler/rustc_privacy/src/lib.rs
View File

@@ -351,7 +351,7 @@ trait VisibilityLike: Sized {
let mut find = FindMin::<_, SHALLOW> { tcx, effective_visibilities, min: Self::MAX };
find.visit(tcx.type_of(def_id).instantiate_identity());
if of_trait {
find.visit_trait(tcx.impl_trait_ref(def_id).unwrap().instantiate_identity());
find.visit_trait(tcx.impl_trait_ref(def_id).instantiate_identity());
}
find.min
}
@@ -828,9 +828,7 @@ impl ReachEverythingInTheInterfaceVisitor<'_, '_> {
}
fn trait_ref(&mut self) -> &mut Self {
self.visit_trait(
self.ev.tcx.impl_trait_ref(self.item_def_id).unwrap().instantiate_identity(),
);
self.visit_trait(self.ev.tcx.impl_trait_ref(self.item_def_id).instantiate_identity());
self
}
}
@@ -1403,8 +1401,7 @@ impl SearchInterfaceForPrivateItemsVisitor<'_> {
fn trait_ref(&mut self) -> &mut Self {
self.in_primary_interface = true;
let _ = self
.visit_trait(self.tcx.impl_trait_ref(self.item_def_id).unwrap().instantiate_identity());
let _ = self.visit_trait(self.tcx.impl_trait_ref(self.item_def_id).instantiate_identity());
self
}
@@ -1778,7 +1775,7 @@ fn check_mod_privacy(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
}
if let DefKind::Impl { of_trait: true } = tcx.def_kind(def_id) {
let trait_ref = tcx.impl_trait_ref(def_id).unwrap();
let trait_ref = tcx.impl_trait_ref(def_id);
let trait_ref = trait_ref.instantiate_identity();
visitor.span =
tcx.hir_expect_item(def_id).expect_impl().of_trait.unwrap().trait_ref.path.span;

2
compiler/rustc_public_bridge/src/context/impls.rs
View File

@@ -189,7 +189,7 @@ impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
}
pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder<'tcx, TraitRef<'tcx>> {
self.tcx.impl_trait_ref(impl_def).unwrap()
self.tcx.impl_trait_ref(impl_def)
}
pub fn generics_of(&self, def_id: DefId) -> &'tcx ty::Generics {

2
compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
View File

@@ -470,7 +470,7 @@ fn implemented_method<'tcx>(
let assoc = tcx.opt_associated_item(instance.def_id())?;
let ancestor = if let AssocContainer::TraitImpl(Ok(trait_method_id)) = assoc.container {
let impl_id = tcx.parent(instance.def_id());
trait_ref = tcx.impl_trait_ref(impl_id).unwrap();
trait_ref = tcx.impl_trait_ref(impl_id);
method_id = trait_method_id;
trait_method = tcx.associated_item(method_id);
trait_id = trait_ref.skip_binder().def_id;

2
compiler/rustc_symbol_mangling/src/legacy.rs
View File

@@ -403,7 +403,7 @@ impl<'tcx> Printer<'tcx> for LegacySymbolMangler<'tcx> {
args: &'tcx [GenericArg<'tcx>],
) -> Result<(), PrintError> {
let self_ty = self.tcx.type_of(impl_def_id);
let impl_trait_ref = self.tcx.impl_trait_ref(impl_def_id);
let impl_trait_ref = self.tcx.impl_opt_trait_ref(impl_def_id);
let generics = self.tcx.generics_of(impl_def_id);
// We have two cases to worry about here:
// 1. We're printing a nested item inside of an impl item, like an inner

2
compiler/rustc_symbol_mangling/src/v0.rs
View File

@@ -311,7 +311,7 @@ impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx> {
let parent_def_id = DefId { index: key.parent.unwrap(), ..impl_def_id };
let self_ty = self.tcx.type_of(impl_def_id);
let impl_trait_ref = self.tcx.impl_trait_ref(impl_def_id);
let impl_trait_ref = self.tcx.impl_opt_trait_ref(impl_def_id);
let generics = self.tcx.generics_of(impl_def_id);
// We have two cases to worry about here:
// 1. We're printing a nested item inside of an impl item, like an inner

2
compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
View File

@@ -574,7 +574,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
let Some(impl_def_id) = self.tcx.trait_impl_of_assoc(impl_item_def_id.to_def_id()) else {
return;
};
let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap();
let trait_ref = self.tcx.impl_trait_ref(impl_def_id);
let trait_args = trait_ref
.instantiate_identity()
// Replace the explicit self type with `Self` for better suggestion rendering

3
compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
View File

@@ -47,8 +47,7 @@ pub fn compute_applicable_impls_for_diagnostics<'tcx>(
);
let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
let impl_trait_ref =
tcx.impl_trait_ref(impl_def_id).unwrap().instantiate(tcx, impl_args);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate(tcx, impl_args);
let impl_trait_ref =
ocx.normalize(&ObligationCause::dummy(), param_env, impl_trait_ref);

2
compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
View File

@@ -354,7 +354,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
pub(crate) fn to_pretty_impl_header(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Option<String> {
use std::fmt::Write;
let trait_ref = tcx.impl_trait_ref(impl_def_id)?.instantiate_identity();
let trait_ref = tcx.impl_opt_trait_ref(impl_def_id)?.instantiate_identity();
let mut w = "impl".to_owned();
#[derive(Debug, Default)]

3
compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
View File

@@ -44,8 +44,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
self.tcx.for_each_relevant_impl(trait_pred.def_id(), trait_self_ty, |def_id| {
let impl_args = self.fresh_args_for_item(obligation.cause.span, def_id);
let impl_trait_ref =
tcx.impl_trait_ref(def_id).unwrap().instantiate(tcx, impl_args);
let impl_trait_ref = tcx.impl_trait_ref(def_id).instantiate(tcx, impl_args);
let impl_self_ty = impl_trait_ref.self_ty();

7
compiler/rustc_trait_selection/src/traits/coherence.rs
View File

@@ -137,8 +137,8 @@ pub fn overlapping_trait_impls(
// Before doing expensive operations like entering an inference context, do
// a quick check via fast_reject to tell if the impl headers could possibly
// unify.
let impl1_args = tcx.impl_trait_ref(impl1_def_id).unwrap().skip_binder().args;
let impl2_args = tcx.impl_trait_ref(impl2_def_id).unwrap().skip_binder().args;
let impl1_args = tcx.impl_trait_ref(impl1_def_id).skip_binder().args;
let impl2_args = tcx.impl_trait_ref(impl2_def_id).skip_binder().args;
let may_overlap =
DeepRejectCtxt::relate_infer_infer(tcx).args_may_unify(impl1_args, impl2_args);
@@ -209,8 +209,7 @@ fn fresh_impl_header<'tcx>(
impl_def_id,
impl_args,
self_ty: tcx.type_of(impl_def_id).instantiate(tcx, impl_args),
trait_ref: is_of_trait
.then(|| tcx.impl_trait_ref(impl_def_id).unwrap().instantiate(tcx, impl_args)),
trait_ref: is_of_trait.then(|| tcx.impl_trait_ref(impl_def_id).instantiate(tcx, impl_args)),
predicates: tcx
.predicates_of(impl_def_id)
.instantiate(tcx, impl_args)

5
compiler/rustc_trait_selection/src/traits/mod.rs
View File

@@ -835,10 +835,7 @@ fn is_impossible_associated_item(
let param_env = ty::ParamEnv::empty();
let fresh_args = infcx.fresh_args_for_item(tcx.def_span(impl_def_id), impl_def_id);
let impl_trait_ref = tcx
.impl_trait_ref(impl_def_id)
.expect("expected impl to correspond to trait")
.instantiate(tcx, fresh_args);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate(tcx, fresh_args);
let mut visitor = ReferencesOnlyParentGenerics { tcx, generics, trait_item_def_id };
let predicates_for_trait = predicates.predicates.iter().filter_map(|(pred, span)| {

14
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View File

@@ -117,7 +117,7 @@ pub fn translate_args_with_cause<'tcx>(
param_env, source_impl, source_args, target_node
);
let source_trait_ref =
infcx.tcx.impl_trait_ref(source_impl).unwrap().instantiate(infcx.tcx, source_args);
infcx.tcx.impl_trait_ref(source_impl).instantiate(infcx.tcx, source_args);
// translate the Self and Param parts of the generic parameters, since those
// vary across impls
@@ -176,11 +176,7 @@ fn fulfill_implication<'tcx>(
let target_trait_ref = ocx.normalize(
cause,
param_env,
infcx
.tcx
.impl_trait_ref(target_impl)
.expect("expected source impl to be a trait impl")
.instantiate(infcx.tcx, target_args),
infcx.tcx.impl_trait_ref(target_impl).instantiate(infcx.tcx, target_args),
);
// do the impls unify? If not, no specialization.
@@ -307,11 +303,7 @@ pub(super) fn specializes(
let parent_impl_trait_ref = ocx.normalize(
cause,
param_env,
infcx
.tcx
.impl_trait_ref(parent_impl_def_id)
.expect("expected source impl to be a trait impl")
.instantiate(infcx.tcx, parent_args),
infcx.tcx.impl_trait_ref(parent_impl_def_id).instantiate(infcx.tcx, parent_args),
);
// do the impls unify? If not, no specialization.

10
compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
View File

@@ -38,7 +38,7 @@ enum Inserted<'tcx> {
impl<'tcx> Children {
/// Insert an impl into this set of children without comparing to any existing impls.
fn insert_blindly(&mut self, tcx: TyCtxt<'tcx>, impl_def_id: DefId) {
let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().skip_binder();
let trait_ref = tcx.impl_trait_ref(impl_def_id).skip_binder();
if let Some(st) =
fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::InstantiateWithInfer)
{
@@ -54,7 +54,7 @@ impl<'tcx> Children {
/// an impl with a parent. The impl must be present in the list of
/// children already.
fn remove_existing(&mut self, tcx: TyCtxt<'tcx>, impl_def_id: DefId) {
let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().skip_binder();
let trait_ref = tcx.impl_trait_ref(impl_def_id).skip_binder();
let vec: &mut Vec<DefId>;
if let Some(st) =
fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::InstantiateWithInfer)
@@ -164,7 +164,7 @@ impl<'tcx> Children {
if le && !ge {
debug!(
"descending as child of TraitRef {:?}",
tcx.impl_trait_ref(possible_sibling).unwrap().instantiate_identity()
tcx.impl_trait_ref(possible_sibling).instantiate_identity()
);
// The impl specializes `possible_sibling`.
@@ -172,7 +172,7 @@ impl<'tcx> Children {
} else if ge && !le {
debug!(
"placing as parent of TraitRef {:?}",
tcx.impl_trait_ref(possible_sibling).unwrap().instantiate_identity()
tcx.impl_trait_ref(possible_sibling).instantiate_identity()
);
replace_children.push(possible_sibling);
@@ -242,7 +242,7 @@ impl<'tcx> Graph {
assert!(impl_def_id.is_local());
// FIXME: use `EarlyBinder` in `self.children`
let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().skip_binder();
let trait_ref = tcx.impl_trait_ref(impl_def_id).skip_binder();
let trait_def_id = trait_ref.def_id;
debug!(

4
compiler/rustc_ty_utils/src/implied_bounds.rs
View File

@@ -46,7 +46,7 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx [(Ty<'
// Trait arguments and the self type for trait impls or only the self type for
// inherent impls.
let tys = if of_trait {
let trait_ref = tcx.impl_trait_ref(def_id).unwrap();
let trait_ref = tcx.impl_trait_ref(def_id);
trait_ref.skip_binder().args.types().collect()
} else {
vec![tcx.type_of(def_id).instantiate_identity()]
@@ -113,7 +113,7 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx [(Ty<'
let args = ty::GenericArgs::identity_for_item(tcx, def_id).rebase_onto(
tcx,
impl_def_id.to_def_id(),
tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity().args,
tcx.impl_trait_ref(impl_def_id).instantiate_identity().args,
);
tcx.arena.alloc_from_iter(
ty::EarlyBinder::bind(tcx.assumed_wf_types_for_rpitit(rpitit_def_id))

3
compiler/rustc_ty_utils/src/opaque_types.rs
View File

@@ -219,8 +219,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx> {
// supporting the case of a method defining opaque types from assoc types
// in the same impl block.
if let Some(parent) = self.tcx.trait_impl_of_assoc(self.item.to_def_id()) {
let impl_trait_ref =
self.tcx.impl_trait_ref(parent).unwrap().instantiate_identity();
let impl_trait_ref = self.tcx.impl_trait_ref(parent).instantiate_identity();
// If the trait ref of the associated item and the impl differs,
// then we can't use the impl's identity args below, so
// just skip.

2
compiler/rustc_ty_utils/src/sig_types.rs
View File

@@ -88,7 +88,7 @@ pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
DefKind::Impl { of_trait } => {
if of_trait {
let span = tcx.hir_node_by_def_id(item).expect_item().expect_impl().of_trait.unwrap().trait_ref.path.span;
let args = &tcx.impl_trait_ref(item).unwrap().instantiate_identity().args[1..];
let args = &tcx.impl_trait_ref(item).instantiate_identity().args[1..];
try_visit!(visitor.visit(span, args));
}
let span = match tcx.hir_node_by_def_id(item).ty() {