bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

ProjectionTy.item_def_id -> ProjectionTy.def_id

Browse source
This commit is contained in:
Michael Goulet 2022-11-26 21:21:20 +00:00
parent 7f3af72606
commit 5c6afb850c
50 changed files with 164 additions and 186 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
View file

@ -235,7 +235,7 @@ fn push_debuginfo_type_name<'tcx>(
let projection_bounds: SmallVec<[_; 4]> = trait_data let projection_bounds: SmallVec<[_; 4]> = trait_data
.projection_bounds() .projection_bounds()
.map(|bound| { .map(|bound| {
let ExistentialProjection { item_def_id, term, .. } = let ExistentialProjection { def_id: item_def_id, term, .. } =
tcx.erase_late_bound_regions(bound); tcx.erase_late_bound_regions(bound);
// FIXME(associated_const_equality): allow for consts here // FIXME(associated_const_equality): allow for consts here
(item_def_id, term.ty().unwrap()) (item_def_id, term.ty().unwrap())

2
compiler/rustc_const_eval/src/util/type_name.rs
View file

@ -59,7 +59,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
ty::Adt(ty::AdtDef(Interned(&ty::AdtDefData { did: def_id, .. }, _)), substs) ty::Adt(ty::AdtDef(Interned(&ty::AdtDefData { did: def_id, .. }, _)), substs)
| ty::FnDef(def_id, substs) | ty::FnDef(def_id, substs)
| ty::Opaque(ty::OpaqueTy { def_id, substs }) | ty::Opaque(ty::OpaqueTy { def_id, substs })
| ty::Projection(ty::ProjectionTy { item_def_id: def_id, substs }) | ty::Projection(ty::ProjectionTy { def_id, substs })
| ty::Closure(def_id, substs) | ty::Closure(def_id, substs)
| ty::Generator(def_id, substs, _) => self.print_def_path(def_id, substs), | ty::Generator(def_id, substs, _) => self.print_def_path(def_id, substs),
ty::Foreign(def_id) => self.print_def_path(def_id, &[]), ty::Foreign(def_id) => self.print_def_path(def_id, &[]),

7
compiler/rustc_hir_analysis/src/astconv/mod.rs
View file

@ -1146,10 +1146,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
debug!(?substs_trait_ref_and_assoc_item); debug!(?substs_trait_ref_and_assoc_item);
ty::ProjectionTy { ty::ProjectionTy { def_id: assoc_item.def_id, substs: substs_trait_ref_and_assoc_item }
item_def_id: assoc_item.def_id,
substs: substs_trait_ref_and_assoc_item,
}
}); });
if !speculative { if !speculative {
@ -1195,7 +1192,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// the "projection predicate" for: // the "projection predicate" for:
// //
// `<T as Iterator>::Item = u32` // `<T as Iterator>::Item = u32`
let assoc_item_def_id = projection_ty.skip_binder().item_def_id; let assoc_item_def_id = projection_ty.skip_binder().def_id;
let def_kind = tcx.def_kind(assoc_item_def_id); let def_kind = tcx.def_kind(assoc_item_def_id);
match (def_kind, term.unpack()) { match (def_kind, term.unpack()) {
(hir::def::DefKind::AssocTy, ty::TermKind::Ty(_)) (hir::def::DefKind::AssocTy, ty::TermKind::Ty(_))

14
compiler/rustc_hir_analysis/src/check/compare_method.rs
View file

@ -572,9 +572,9 @@ impl<'tcx> TypeFolder<'tcx> for ImplTraitInTraitCollector<'_, 'tcx> {
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
if let ty::Projection(proj) = ty.kind() if let ty::Projection(proj) = ty.kind()
&& self.tcx().def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder && self.tcx().def_kind(proj.def_id) == DefKind::ImplTraitPlaceholder
{ {
if let Some((ty, _)) = self.types.get(&proj.item_def_id) { if let Some((ty, _)) = self.types.get(&proj.def_id) {
return *ty; return *ty;
} }
//FIXME(RPITIT): Deny nested RPITIT in substs too //FIXME(RPITIT): Deny nested RPITIT in substs too
@ -586,9 +586,9 @@ impl<'tcx> TypeFolder<'tcx> for ImplTraitInTraitCollector<'_, 'tcx> {
span: self.span, span: self.span,
kind: TypeVariableOriginKind::MiscVariable, kind: TypeVariableOriginKind::MiscVariable,
}); });
self.types.insert(proj.item_def_id, (infer_ty, proj.substs)); self.types.insert(proj.def_id, (infer_ty, proj.substs));
// Recurse into bounds // Recurse into bounds
for (pred, pred_span) in self.tcx().bound_explicit_item_bounds(proj.item_def_id).subst_iter_copied(self.tcx(), proj.substs) { for (pred, pred_span) in self.tcx().bound_explicit_item_bounds(proj.def_id).subst_iter_copied(self.tcx(), proj.substs) {
let pred = pred.fold_with(self); let pred = pred.fold_with(self);
let pred = self.ocx.normalize( let pred = self.ocx.normalize(
&ObligationCause::misc(self.span, self.body_id), &ObligationCause::misc(self.span, self.body_id),
@ -601,7 +601,7 @@ impl<'tcx> TypeFolder<'tcx> for ImplTraitInTraitCollector<'_, 'tcx> {
ObligationCause::new( ObligationCause::new(
self.span, self.span,
self.body_id, self.body_id,
ObligationCauseCode::BindingObligation(proj.item_def_id, pred_span), ObligationCauseCode::BindingObligation(proj.def_id, pred_span),
), ),
self.param_env, self.param_env,
pred, pred,
@ -1735,7 +1735,7 @@ pub fn check_type_bounds<'tcx>(
let mut predicates = param_env.caller_bounds().iter().collect::<Vec<_>>(); let mut predicates = param_env.caller_bounds().iter().collect::<Vec<_>>();
match impl_ty_value.kind() { match impl_ty_value.kind() {
ty::Projection(proj) ty::Projection(proj)
if proj.item_def_id == trait_ty.def_id && proj.substs == rebased_substs => if proj.def_id == trait_ty.def_id && proj.substs == rebased_substs =>
{ {
// Don't include this predicate if the projected type is // Don't include this predicate if the projected type is
// exactly the same as the projection. This can occur in // exactly the same as the projection. This can occur in
@ -1747,7 +1747,7 @@ pub fn check_type_bounds<'tcx>(
ty::Binder::bind_with_vars( ty::Binder::bind_with_vars(
ty::ProjectionPredicate { ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { projection_ty: ty::ProjectionTy {
item_def_id: trait_ty.def_id, def_id: trait_ty.def_id,
substs: rebased_substs, substs: rebased_substs,
}, },
term: impl_ty_value.into(), term: impl_ty_value.into(),

6
compiler/rustc_hir_analysis/src/check/mod.rs
View file

@ -352,11 +352,7 @@ fn bounds_from_generic_predicates<'tcx>(
// insert the associated types where they correspond, but for now let's be "lazy" and // insert the associated types where they correspond, but for now let's be "lazy" and
// propose this instead of the following valid resugaring: // propose this instead of the following valid resugaring:
// `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>` // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
where_clauses.push(format!( where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.def_id), p.term,));
"{} = {}",
tcx.def_path_str(p.projection_ty.item_def_id),
p.term,
));
} }
let where_clauses = if where_clauses.is_empty() { let where_clauses = if where_clauses.is_empty() {
String::new() String::new()

10
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View file

@ -759,7 +759,7 @@ impl<'tcx> TypeVisitor<'tcx> for GATSubstCollector<'tcx> {
fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> { fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
match t.kind() { match t.kind() {
ty::Projection(p) if p.item_def_id == self.gat => { ty::Projection(p) if p.def_id == self.gat => {
for (idx, subst) in p.substs.iter().enumerate() { for (idx, subst) in p.substs.iter().enumerate() {
match subst.unpack() { match subst.unpack() {
GenericArgKind::Lifetime(lt) if !lt.is_late_bound() => { GenericArgKind::Lifetime(lt) if !lt.is_late_bound() => {
@ -1593,11 +1593,11 @@ fn check_return_position_impl_trait_in_trait_bounds<'tcx>(
for arg in fn_output.walk() { for arg in fn_output.walk() {
if let ty::GenericArgKind::Type(ty) = arg.unpack() if let ty::GenericArgKind::Type(ty) = arg.unpack()
&& let ty::Projection(proj) = ty.kind() && let ty::Projection(proj) = ty.kind()
&& tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder && tcx.def_kind(proj.def_id) == DefKind::ImplTraitPlaceholder
&& tcx.impl_trait_in_trait_parent(proj.item_def_id) == fn_def_id.to_def_id() && tcx.impl_trait_in_trait_parent(proj.def_id) == fn_def_id.to_def_id()
{ {
let span = tcx.def_span(proj.item_def_id); let span = tcx.def_span(proj.def_id);
let bounds = wfcx.tcx().explicit_item_bounds(proj.item_def_id); let bounds = wfcx.tcx().explicit_item_bounds(proj.def_id);
let wf_obligations = bounds.iter().flat_map(|&(bound, bound_span)| { let wf_obligations = bounds.iter().flat_map(|&(bound, bound_span)| {
let bound = ty::EarlyBinder(bound).subst(tcx, proj.substs); let bound = ty::EarlyBinder(bound).subst(tcx, proj.substs);
let normalized_bound = wfcx.normalize(span, None, bound); let normalized_bound = wfcx.normalize(span, None, bound);

2
compiler/rustc_hir_analysis/src/collect/predicates_of.rs
View file

@ -413,7 +413,7 @@ pub(super) fn explicit_predicates_of<'tcx>(
// supertrait). // supertrait).
if let ty::Projection(projection) = ty.kind() { if let ty::Projection(projection) = ty.kind() {
projection.substs == trait_identity_substs projection.substs == trait_identity_substs
&& tcx.associated_item(projection.item_def_id).container_id(tcx) == def_id && tcx.associated_item(projection.def_id).container_id(tcx) == def_id
} else { } else {
false false
} }

2
compiler/rustc_hir_analysis/src/collect/type_of.rs
View file

@ -69,7 +69,7 @@ pub(super) fn opt_const_param_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<
// as a precaution for if it's ever allowed to elide lifetimes in GAT's. It currently isn't // as a precaution for if it's ever allowed to elide lifetimes in GAT's. It currently isn't
// but it can't hurt to be safe ^^ // but it can't hurt to be safe ^^
if let ty::Projection(projection) = ty.kind() { if let ty::Projection(projection) = ty.kind() {
let generics = tcx.generics_of(projection.item_def_id); let generics = tcx.generics_of(projection.def_id);
let arg_index = segment let arg_index = segment
.args .args

2
compiler/rustc_hir_analysis/src/outlives/implicit_infer.rs
View file

@ -202,7 +202,7 @@ fn insert_required_predicates_to_be_wf<'tcx>(
debug!("Projection"); debug!("Projection");
check_explicit_predicates( check_explicit_predicates(
tcx, tcx,
tcx.parent(obj.item_def_id), tcx.parent(obj.def_id),
obj.substs, obj.substs,
required_predicates, required_predicates,
explicit_map, explicit_map,

2
compiler/rustc_hir_analysis/src/outlives/utils.rs
View file

@ -90,7 +90,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
// ``` // ```
// //
// Here we want to add an explicit `where <T as Iterator>::Item: 'a`. // Here we want to add an explicit `where <T as Iterator>::Item: 'a`.
let ty: Ty<'tcx> = tcx.mk_projection(proj_ty.item_def_id, proj_ty.substs); let ty: Ty<'tcx> = tcx.mk_projection(proj_ty.def_id, proj_ty.substs);
required_predicates required_predicates
.entry(ty::OutlivesPredicate(ty.into(), outlived_region)) .entry(ty::OutlivesPredicate(ty.into(), outlived_region))
.or_insert(span); .or_insert(span);

9
compiler/rustc_hir_analysis/src/variance/mod.rs
View file

@ -110,12 +110,13 @@ fn variance_of_opaque(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Varianc
#[instrument(level = "trace", skip(self), ret)] #[instrument(level = "trace", skip(self), ret)]
fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> { fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
// FIXME(alias): merge these
match t.kind() { match t.kind() {
ty::Opaque(def_id, substs) => self.visit_opaque(*def_id, substs), ty::Opaque(ty::OpaqueTy { def_id, substs }) => self.visit_opaque(*def_id, substs),
ty::Projection(proj) ty::Projection(proj)
if self.tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder => if self.tcx.def_kind(proj.def_id) == DefKind::ImplTraitPlaceholder =>
{ {
self.visit_opaque(proj.item_def_id, proj.substs) self.visit_opaque(proj.def_id, proj.substs)
} }
_ => t.super_visit_with(self), _ => t.super_visit_with(self),
} }
@ -167,7 +168,7 @@ fn variance_of_opaque(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Varianc
} }
} }
ty::PredicateKind::Clause(ty::Clause::Projection(ty::ProjectionPredicate { ty::PredicateKind::Clause(ty::Clause::Projection(ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { substs, item_def_id: _ }, projection_ty: ty::ProjectionTy { substs, def_id: _ },
term, term,
})) => { })) => {
for subst in &substs[1..] { for subst in &substs[1..] {

8
compiler/rustc_hir_typeck/src/closure.rs
View file

@ -684,10 +684,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.find_map(|(p, s)| get_future_output(p, s))?, .find_map(|(p, s)| get_future_output(p, s))?,
ty::Error(_) => return None, ty::Error(_) => return None,
ty::Projection(proj) ty::Projection(proj)
if self.tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder => if self.tcx.def_kind(proj.def_id) == DefKind::ImplTraitPlaceholder =>
{ {
self.tcx self.tcx
.bound_explicit_item_bounds(proj.item_def_id) .bound_explicit_item_bounds(proj.def_id)
.subst_iter_copied(self.tcx, proj.substs) .subst_iter_copied(self.tcx, proj.substs)
.find_map(|(p, s)| get_future_output(p, s))? .find_map(|(p, s)| get_future_output(p, s))?
} }
@ -743,11 +743,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// The `Future` trait has only one associated item, `Output`, // The `Future` trait has only one associated item, `Output`,
// so check that this is what we see. // so check that this is what we see.
let output_assoc_item = self.tcx.associated_item_def_ids(future_trait)[0]; let output_assoc_item = self.tcx.associated_item_def_ids(future_trait)[0];
if output_assoc_item != predicate.projection_ty.item_def_id { if output_assoc_item != predicate.projection_ty.def_id {
span_bug!( span_bug!(
cause_span, cause_span,
"projecting associated item `{:?}` from future, which is not Output `{:?}`", "projecting associated item `{:?}` from future, which is not Output `{:?}`",
predicate.projection_ty.item_def_id, predicate.projection_ty.def_id,
output_assoc_item, output_assoc_item,
); );
} }

6
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View file

@ -177,7 +177,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ty::Opaque(ty::OpaqueTy { def_id, substs }) => { ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
self.tcx.bound_item_bounds(def_id).subst(self.tcx, substs).iter().find_map(|pred| { self.tcx.bound_item_bounds(def_id).subst(self.tcx, substs).iter().find_map(|pred| {
if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder() if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder()
&& Some(proj.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output() && Some(proj.projection_ty.def_id) == self.tcx.lang_items().fn_once_output()
// args tuple will always be substs[1] // args tuple will always be substs[1]
&& let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind() && let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind()
{ {
@ -194,7 +194,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ty::Dynamic(data, _, ty::Dyn) => { ty::Dynamic(data, _, ty::Dyn) => {
data.iter().find_map(|pred| { data.iter().find_map(|pred| {
if let ty::ExistentialPredicate::Projection(proj) = pred.skip_binder() if let ty::ExistentialPredicate::Projection(proj) = pred.skip_binder()
&& Some(proj.item_def_id) == self.tcx.lang_items().fn_once_output() && Some(proj.def_id) == self.tcx.lang_items().fn_once_output()
// for existential projection, substs are shifted over by 1 // for existential projection, substs are shifted over by 1
&& let ty::Tuple(args) = proj.substs.type_at(0).kind() && let ty::Tuple(args) = proj.substs.type_at(0).kind()
{ {
@ -212,7 +212,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let def_id = self.tcx.generics_of(self.body_id.owner).type_param(&param, self.tcx).def_id; let def_id = self.tcx.generics_of(self.body_id.owner).type_param(&param, self.tcx).def_id;
self.tcx.predicates_of(self.body_id.owner).predicates.iter().find_map(|(pred, _)| { self.tcx.predicates_of(self.body_id.owner).predicates.iter().find_map(|(pred, _)| {
if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder() if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder()
&& Some(proj.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output() && Some(proj.projection_ty.def_id) == self.tcx.lang_items().fn_once_output()
&& proj.projection_ty.self_ty() == found && proj.projection_ty.self_ty() == found
// args tuple will always be substs[1] // args tuple will always be substs[1]
&& let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind() && let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind()

4
compiler/rustc_hir_typeck/src/method/suggest.rs
View file

@ -559,7 +559,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let quiet_projection_ty = ty::ProjectionTy { let quiet_projection_ty = ty::ProjectionTy {
substs: substs_with_infer_self, substs: substs_with_infer_self,
item_def_id: projection_ty.item_def_id, def_id: projection_ty.def_id,
}; };
let term = pred.skip_binder().term; let term = pred.skip_binder().term;
@ -2269,7 +2269,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
t.def_id() == info.def_id t.def_id() == info.def_id
} }
ty::PredicateKind::Clause(ty::Clause::Projection(p)) => { ty::PredicateKind::Clause(ty::Clause::Projection(p)) => {
p.projection_ty.item_def_id == info.def_id p.projection_ty.def_id == info.def_id
} }
_ => false, _ => false,
} }

4
compiler/rustc_infer/src/infer/at.rs
View file

@ -419,8 +419,8 @@ impl<'tcx> ToTrace<'tcx> for ty::ProjectionTy<'tcx> {
a: Self, a: Self,
b: Self, b: Self,
) -> TypeTrace<'tcx> { ) -> TypeTrace<'tcx> {
let a_ty = tcx.mk_projection(a.item_def_id, a.substs); let a_ty = tcx.mk_projection(a.def_id, a.substs);
let b_ty = tcx.mk_projection(b.item_def_id, b.substs); let b_ty = tcx.mk_projection(b.def_id, b.substs);
TypeTrace { TypeTrace {
cause: cause.clone(), cause: cause.clone(),
values: Terms(ExpectedFound::new(a_is_expected, a_ty.into(), b_ty.into())), values: Terms(ExpectedFound::new(a_is_expected, a_ty.into(), b_ty.into())),

10
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View file

@ -342,9 +342,9 @@ impl<'tcx> InferCtxt<'tcx> {
let (def_id, substs) = match *ty.kind() { let (def_id, substs) = match *ty.kind() {
ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs), ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs),
ty::Projection(data) ty::Projection(data)
if self.tcx.def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder => if self.tcx.def_kind(data.def_id) == DefKind::ImplTraitPlaceholder =>
{ {
(data.item_def_id, data.substs) (data.def_id, data.substs)
} }
_ => return None, _ => return None,
}; };
@ -358,7 +358,7 @@ impl<'tcx> InferCtxt<'tcx> {
.kind() .kind()
.map_bound(|kind| match kind { .map_bound(|kind| match kind {
ty::PredicateKind::Clause(ty::Clause::Projection(projection_predicate)) ty::PredicateKind::Clause(ty::Clause::Projection(projection_predicate))
if projection_predicate.projection_ty.item_def_id == item_def_id => if projection_predicate.projection_ty.def_id == item_def_id =>
{ {
projection_predicate.term.ty() projection_predicate.term.ty()
} }
@ -1743,11 +1743,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
) )
} }
(true, ty::Projection(proj)) (true, ty::Projection(proj))
if self.tcx.def_kind(proj.item_def_id) if self.tcx.def_kind(proj.def_id)
== DefKind::ImplTraitPlaceholder => == DefKind::ImplTraitPlaceholder =>
{ {
let sm = self.tcx.sess.source_map(); let sm = self.tcx.sess.source_map();
let pos = sm.lookup_char_pos(self.tcx.def_span(proj.item_def_id).lo()); let pos = sm.lookup_char_pos(self.tcx.def_span(proj.def_id).lo());
format!( format!(
" (trait associated opaque type at <{}:{}:{}>)", " (trait associated opaque type at <{}:{}:{}>)",
sm.filename_for_diagnostics(&pos.file.name), sm.filename_for_diagnostics(&pos.file.name),

2
compiler/rustc_infer/src/infer/error_reporting/suggest.rs
View file

@ -509,7 +509,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
( (
hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: last_bounds, .. }), hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: last_bounds, .. }),
hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: exp_bounds, .. }), hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: exp_bounds, .. }),
) if iter::zip(*last_bounds, *exp_bounds).all(|(left, right)| { ) if std::iter::zip(*last_bounds, *exp_bounds).all(|(left, right)| {
match (left, right) { match (left, right) {
( (
hir::GenericBound::Trait(tl, ml), hir::GenericBound::Trait(tl, ml),

8
compiler/rustc_infer/src/infer/opaque_types.rs
View file

@ -490,10 +490,10 @@ where
} }
ty::Projection(proj) ty::Projection(proj)
if self.tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder => if self.tcx.def_kind(proj.def_id) == DefKind::ImplTraitPlaceholder =>
{ {
// Skip lifetime paramters that are not captures. // Skip lifetime paramters that are not captures.
let variances = self.tcx.variances_of(proj.item_def_id); let variances = self.tcx.variances_of(proj.def_id);
for (v, s) in std::iter::zip(variances, proj.substs.iter()) { for (v, s) in std::iter::zip(variances, proj.substs.iter()) {
if *v != ty::Variance::Bivariant { if *v != ty::Variance::Bivariant {
@ -568,7 +568,7 @@ impl<'tcx> InferCtxt<'tcx> {
// FIXME(RPITIT): Don't replace RPITITs with inference vars. // FIXME(RPITIT): Don't replace RPITITs with inference vars.
ty::Projection(projection_ty) ty::Projection(projection_ty)
if !projection_ty.has_escaping_bound_vars() if !projection_ty.has_escaping_bound_vars()
&& tcx.def_kind(projection_ty.item_def_id) && tcx.def_kind(projection_ty.def_id)
!= DefKind::ImplTraitPlaceholder => != DefKind::ImplTraitPlaceholder =>
{ {
self.infer_projection( self.infer_projection(
@ -588,7 +588,7 @@ impl<'tcx> InferCtxt<'tcx> {
} }
// FIXME(RPITIT): This can go away when we move to associated types // FIXME(RPITIT): This can go away when we move to associated types
ty::Projection(proj) ty::Projection(proj)
if def_id.to_def_id() == proj.item_def_id && substs == proj.substs => if def_id.to_def_id() == proj.def_id && substs == proj.substs =>
{ {
hidden_ty hidden_ty
} }

4
compiler/rustc_infer/src/infer/outlives/obligations.rs
View file

@ -355,11 +355,11 @@ where
origin, origin,
region, region,
GenericKind::Projection(projection_ty), GenericKind::Projection(projection_ty),
projection_ty.item_def_id, projection_ty.def_id,
projection_ty.substs, projection_ty.substs,
false, false,
|ty| match ty.kind() { |ty| match ty.kind() {
ty::Projection(projection_ty) => (projection_ty.item_def_id, projection_ty.substs), ty::Projection(projection_ty) => (projection_ty.def_id, projection_ty.substs),
_ => bug!("expected only projection types from env, not {:?}", ty), _ => bug!("expected only projection types from env, not {:?}", ty),
}, },
); );

2
compiler/rustc_infer/src/infer/outlives/verify.rs
View file

@ -178,7 +178,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
), ),
Component::Projection(projection_ty) => self.projection_opaque_bounds( Component::Projection(projection_ty) => self.projection_opaque_bounds(
GenericKind::Projection(projection_ty), GenericKind::Projection(projection_ty),
projection_ty.item_def_id, projection_ty.def_id,
projection_ty.substs, projection_ty.substs,
visited, visited,
), ),

2
compiler/rustc_infer/src/infer/projection.rs
View file

@ -21,7 +21,7 @@ impl<'tcx> InferCtxt<'tcx> {
recursion_depth: usize, recursion_depth: usize,
obligations: &mut Vec<PredicateObligation<'tcx>>, obligations: &mut Vec<PredicateObligation<'tcx>>,
) -> Ty<'tcx> { ) -> Ty<'tcx> {
let def_id = projection_ty.item_def_id; let def_id = projection_ty.def_id;
let ty_var = self.next_ty_var(TypeVariableOrigin { let ty_var = self.next_ty_var(TypeVariableOrigin {
kind: TypeVariableOriginKind::NormalizeProjectionType, kind: TypeVariableOriginKind::NormalizeProjectionType,
span: self.tcx.def_span(def_id), span: self.tcx.def_span(def_id),

2
compiler/rustc_infer/src/infer/region_constraints/mod.rs
View file

@ -773,7 +773,7 @@ impl<'tcx> GenericKind<'tcx> {
pub fn to_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { pub fn to_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
match *self { match *self {
GenericKind::Param(ref p) => p.to_ty(tcx), GenericKind::Param(ref p) => p.to_ty(tcx),
GenericKind::Projection(ref p) => tcx.mk_projection(p.item_def_id, p.substs), GenericKind::Projection(ref p) => tcx.mk_projection(p.def_id, p.substs),
GenericKind::Opaque(def_id, substs) => tcx.mk_opaque(def_id, substs), GenericKind::Opaque(def_id, substs) => tcx.mk_opaque(def_id, substs),
} }
} }

3
compiler/rustc_infer/src/traits/util.rs
View file

@ -259,8 +259,7 @@ impl<'tcx> Elaborator<'tcx> {
Component::Projection(projection) => { Component::Projection(projection) => {
// We might end up here if we have `Foo<<Bar as Baz>::Assoc>: 'a`. // We might end up here if we have `Foo<<Bar as Baz>::Assoc>: 'a`.
// With this, we can deduce that `<Bar as Baz>::Assoc: 'a`. // With this, we can deduce that `<Bar as Baz>::Assoc: 'a`.
let ty = let ty = tcx.mk_projection(projection.def_id, projection.substs);
tcx.mk_projection(projection.item_def_id, projection.substs);
Some(ty::PredicateKind::Clause(ty::Clause::TypeOutlives( Some(ty::PredicateKind::Clause(ty::Clause::TypeOutlives(
ty::OutlivesPredicate(ty, r_min), ty::OutlivesPredicate(ty, r_min),
))) )))

4
compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
View file

@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
let Some(proj_term) = proj.term.ty() else { continue }; let Some(proj_term) = proj.term.ty() else { continue };
let proj_ty = let proj_ty =
cx.tcx.mk_projection(proj.projection_ty.item_def_id, proj.projection_ty.substs); cx.tcx.mk_projection(proj.projection_ty.def_id, proj.projection_ty.substs);
// For every instance of the projection type in the bounds, // For every instance of the projection type in the bounds,
// replace them with the term we're assigning to the associated // replace them with the term we're assigning to the associated
// type in our opaque type. // type in our opaque type.
@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
// with `impl Send: OtherTrait`. // with `impl Send: OtherTrait`.
for (assoc_pred, assoc_pred_span) in cx for (assoc_pred, assoc_pred_span) in cx
.tcx .tcx
.bound_explicit_item_bounds(proj.projection_ty.item_def_id) .bound_explicit_item_bounds(proj.projection_ty.def_id)
.subst_iter_copied(cx.tcx, &proj.projection_ty.substs) .subst_iter_copied(cx.tcx, &proj.projection_ty.substs)
{ {
let assoc_pred = assoc_pred.fold_with(proj_replacer); let assoc_pred = assoc_pred.fold_with(proj_replacer);

2
compiler/rustc_metadata/src/rmeta/encoder.rs
View file

@ -1112,7 +1112,7 @@ fn should_encode_trait_impl_trait_tys<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) ->
tcx.fn_sig(trait_item_def_id).skip_binder().output().walk().any(|arg| { tcx.fn_sig(trait_item_def_id).skip_binder().output().walk().any(|arg| {
if let ty::GenericArgKind::Type(ty) = arg.unpack() if let ty::GenericArgKind::Type(ty) = arg.unpack()
&& let ty::Projection(data) = ty.kind() && let ty::Projection(data) = ty.kind()
&& tcx.def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder && tcx.def_kind(data.def_id) == DefKind::ImplTraitPlaceholder
{ {
true true
} else { } else {

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

@ -2599,7 +2599,7 @@ impl<'tcx> TyCtxt<'tcx> {
substs.len(), substs.len(),
"wrong number of generic parameters for {item_def_id:?}: {substs:?}", "wrong number of generic parameters for {item_def_id:?}: {substs:?}",
); );
self.mk_ty(Projection(ProjectionTy { item_def_id, substs })) self.mk_ty(Projection(ProjectionTy { def_id: item_def_id, substs }))
} }
#[inline] #[inline]

18
compiler/rustc_middle/src/ty/error.rs
View file

@ -443,7 +443,7 @@ impl<'tcx> TyCtxt<'tcx> {
diag.note("an associated type was expected, but a different one was found"); diag.note("an associated type was expected, but a different one was found");
} }
(ty::Param(p), ty::Projection(proj)) | (ty::Projection(proj), ty::Param(p)) (ty::Param(p), ty::Projection(proj)) | (ty::Projection(proj), ty::Param(p))
if self.def_kind(proj.item_def_id) != DefKind::ImplTraitPlaceholder => if self.def_kind(proj.def_id) != DefKind::ImplTraitPlaceholder =>
{ {
let generics = self.generics_of(body_owner_def_id); let generics = self.generics_of(body_owner_def_id);
let p_span = self.def_span(generics.type_param(p, self).def_id); let p_span = self.def_span(generics.type_param(p, self).def_id);
@ -466,7 +466,7 @@ impl<'tcx> TyCtxt<'tcx> {
let (trait_ref, assoc_substs) = proj.trait_ref_and_own_substs(self); let (trait_ref, assoc_substs) = proj.trait_ref_and_own_substs(self);
let path = let path =
self.def_path_str_with_substs(trait_ref.def_id, trait_ref.substs); self.def_path_str_with_substs(trait_ref.def_id, trait_ref.substs);
let item_name = self.item_name(proj.item_def_id); let item_name = self.item_name(proj.def_id);
let item_args = self.format_generic_args(assoc_substs); let item_args = self.format_generic_args(assoc_substs);
let path = if path.ends_with('>') { let path = if path.ends_with('>') {
@ -553,7 +553,7 @@ impl<T> Trait<T> for X {
diag.span_label(p_span, "this type parameter"); diag.span_label(p_span, "this type parameter");
} }
} }
(ty::Projection(proj_ty), _) if self.def_kind(proj_ty.item_def_id) != DefKind::ImplTraitPlaceholder => { (ty::Projection(proj_ty), _) if self.def_kind(proj_ty.def_id) != DefKind::ImplTraitPlaceholder => {
self.expected_projection( self.expected_projection(
diag, diag,
proj_ty, proj_ty,
@ -562,7 +562,7 @@ impl<T> Trait<T> for X {
cause.code(), cause.code(),
); );
} }
(_, ty::Projection(proj_ty)) if self.def_kind(proj_ty.item_def_id) != DefKind::ImplTraitPlaceholder => { (_, ty::Projection(proj_ty)) if self.def_kind(proj_ty.def_id) != DefKind::ImplTraitPlaceholder => {
let msg = format!( let msg = format!(
"consider constraining the associated type `{}` to `{}`", "consider constraining the associated type `{}` to `{}`",
values.found, values.expected, values.found, values.expected,
@ -627,7 +627,7 @@ impl<T> Trait<T> for X {
proj_ty: &ty::ProjectionTy<'tcx>, proj_ty: &ty::ProjectionTy<'tcx>,
ty: Ty<'tcx>, ty: Ty<'tcx>,
) -> bool { ) -> bool {
let assoc = self.associated_item(proj_ty.item_def_id); let assoc = self.associated_item(proj_ty.def_id);
let (trait_ref, assoc_substs) = proj_ty.trait_ref_and_own_substs(self); let (trait_ref, assoc_substs) = proj_ty.trait_ref_and_own_substs(self);
if let Some(item) = self.hir().get_if_local(body_owner_def_id) { if let Some(item) = self.hir().get_if_local(body_owner_def_id) {
if let Some(hir_generics) = item.generics() { if let Some(hir_generics) = item.generics() {
@ -703,7 +703,7 @@ impl<T> Trait<T> for X {
); );
let impl_comparison = let impl_comparison =
matches!(cause_code, ObligationCauseCode::CompareImplItemObligation { .. }); matches!(cause_code, ObligationCauseCode::CompareImplItemObligation { .. });
let assoc = self.associated_item(proj_ty.item_def_id); let assoc = self.associated_item(proj_ty.def_id);
if !callable_scope || impl_comparison { if !callable_scope || impl_comparison {
// We do not want to suggest calling functions when the reason of the // We do not want to suggest calling functions when the reason of the
// type error is a comparison of an `impl` with its `trait` or when the // type error is a comparison of an `impl` with its `trait` or when the
@ -716,7 +716,7 @@ impl<T> Trait<T> for X {
diag, diag,
assoc.container_id(self), assoc.container_id(self),
current_method_ident, current_method_ident,
proj_ty.item_def_id, proj_ty.def_id,
values.expected, values.expected,
); );
// Possibly suggest constraining the associated type to conform to the // Possibly suggest constraining the associated type to conform to the
@ -778,7 +778,7 @@ fn foo(&self) -> Self::T { String::new() }
proj_ty: &ty::ProjectionTy<'tcx>, proj_ty: &ty::ProjectionTy<'tcx>,
ty: Ty<'tcx>, ty: Ty<'tcx>,
) -> bool { ) -> bool {
let assoc = self.associated_item(proj_ty.item_def_id); let assoc = self.associated_item(proj_ty.def_id);
if let ty::Opaque(ty::OpaqueTy { def_id, substs: _ }) = *proj_ty.self_ty().kind() { if let ty::Opaque(ty::OpaqueTy { def_id, substs: _ }) = *proj_ty.self_ty().kind() {
let opaque_local_def_id = def_id.as_local(); let opaque_local_def_id = def_id.as_local();
let opaque_hir_ty = if let Some(opaque_local_def_id) = opaque_local_def_id { let opaque_hir_ty = if let Some(opaque_local_def_id) = opaque_local_def_id {
@ -828,7 +828,7 @@ fn foo(&self) -> Self::T { String::new() }
.filter_map(|(_, item)| { .filter_map(|(_, item)| {
let method = self.fn_sig(item.def_id); let method = self.fn_sig(item.def_id);
match *method.output().skip_binder().kind() { match *method.output().skip_binder().kind() {
ty::Projection(ty::ProjectionTy { item_def_id, .. }) ty::Projection(ty::ProjectionTy { def_id: item_def_id, .. })
if item_def_id == proj_ty_item_def_id => if item_def_id == proj_ty_item_def_id =>
{ {
Some(( Some((

2
compiler/rustc_middle/src/ty/mod.rs
View file

@ -1046,7 +1046,7 @@ impl<'tcx> PolyProjectionPredicate<'tcx> {
/// associated type, which is in `tcx.associated_item(projection_def_id()).container`. /// associated type, which is in `tcx.associated_item(projection_def_id()).container`.
pub fn projection_def_id(&self) -> DefId { pub fn projection_def_id(&self) -> DefId {
// Ok to skip binder since trait `DefId` does not care about regions. // Ok to skip binder since trait `DefId` does not care about regions.
self.skip_binder().projection_ty.item_def_id self.skip_binder().projection_ty.def_id
} }
} }

10
compiler/rustc_middle/src/ty/print/pretty.rs
View file

@ -720,9 +720,9 @@ pub trait PrettyPrinter<'tcx>:
} }
ty::Projection(ref data) => { ty::Projection(ref data) => {
if !(self.should_print_verbose() || NO_QUERIES.with(|q| q.get())) if !(self.should_print_verbose() || NO_QUERIES.with(|q| q.get()))
&& self.tcx().def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder && self.tcx().def_kind(data.def_id) == DefKind::ImplTraitPlaceholder
{ {
return self.pretty_print_opaque_impl_type(data.item_def_id, data.substs); return self.pretty_print_opaque_impl_type(data.def_id, data.substs);
} else { } else {
p!(print(data)) p!(print(data))
} }
@ -1022,7 +1022,7 @@ pub trait PrettyPrinter<'tcx>:
// unless we can find out what generator return type it comes from. // unless we can find out what generator return type it comes from.
let term = if let Some(ty) = term.skip_binder().ty() let term = if let Some(ty) = term.skip_binder().ty()
&& let ty::Projection(proj) = ty.kind() && let ty::Projection(proj) = ty.kind()
&& let Some(assoc) = tcx.opt_associated_item(proj.item_def_id) && let Some(assoc) = tcx.opt_associated_item(proj.def_id)
&& assoc.trait_container(tcx) == tcx.lang_items().gen_trait() && assoc.trait_container(tcx) == tcx.lang_items().gen_trait()
&& assoc.name == rustc_span::sym::Return && assoc.name == rustc_span::sym::Return
{ {
@ -2655,7 +2655,7 @@ define_print_and_forward_display! {
} }
ty::ExistentialProjection<'tcx> { ty::ExistentialProjection<'tcx> {
let name = cx.tcx().associated_item(self.item_def_id).name; let name = cx.tcx().associated_item(self.def_id).name;
p!(write("{} = ", name), print(self.term)) p!(write("{} = ", name), print(self.term))
} }
@ -2743,7 +2743,7 @@ define_print_and_forward_display! {
} }
ty::ProjectionTy<'tcx> { ty::ProjectionTy<'tcx> {
p!(print_def_path(self.item_def_id, self.substs)); p!(print_def_path(self.def_id, self.substs));
} }
ty::ClosureKind { ty::ClosureKind {

22
compiler/rustc_middle/src/ty/relate.rs
View file

@ -276,15 +276,11 @@ impl<'tcx> Relate<'tcx> for ty::ProjectionTy<'tcx> {
a: ty::ProjectionTy<'tcx>, a: ty::ProjectionTy<'tcx>,
b: ty::ProjectionTy<'tcx>, b: ty::ProjectionTy<'tcx>,
) -> RelateResult<'tcx, ty::ProjectionTy<'tcx>> { ) -> RelateResult<'tcx, ty::ProjectionTy<'tcx>> {
if a.item_def_id != b.item_def_id { if a.def_id != b.def_id {
Err(TypeError::ProjectionMismatched(expected_found( Err(TypeError::ProjectionMismatched(expected_found(relation, a.def_id, b.def_id)))
relation,
a.item_def_id,
b.item_def_id,
)))
} else { } else {
let substs = relation.relate(a.substs, b.substs)?; let substs = relation.relate(a.substs, b.substs)?;
Ok(ty::ProjectionTy { item_def_id: a.item_def_id, substs: &substs }) Ok(ty::ProjectionTy { def_id: a.def_id, substs: &substs })
} }
} }
} }
@ -295,12 +291,8 @@ impl<'tcx> Relate<'tcx> for ty::ExistentialProjection<'tcx> {
a: ty::ExistentialProjection<'tcx>, a: ty::ExistentialProjection<'tcx>,
b: ty::ExistentialProjection<'tcx>, b: ty::ExistentialProjection<'tcx>,
) -> RelateResult<'tcx, ty::ExistentialProjection<'tcx>> { ) -> RelateResult<'tcx, ty::ExistentialProjection<'tcx>> {
if a.item_def_id != b.item_def_id { if a.def_id != b.def_id {
Err(TypeError::ProjectionMismatched(expected_found( Err(TypeError::ProjectionMismatched(expected_found(relation, a.def_id, b.def_id)))
relation,
a.item_def_id,
b.item_def_id,
)))
} else { } else {
let term = relation.relate_with_variance( let term = relation.relate_with_variance(
ty::Invariant, ty::Invariant,
@ -314,7 +306,7 @@ impl<'tcx> Relate<'tcx> for ty::ExistentialProjection<'tcx> {
a.substs, a.substs,
b.substs, b.substs,
)?; )?;
Ok(ty::ExistentialProjection { item_def_id: a.item_def_id, substs, term }) Ok(ty::ExistentialProjection { def_id: a.def_id, substs, term })
} }
} }
} }
@ -561,7 +553,7 @@ pub fn super_relate_tys<'tcx, R: TypeRelation<'tcx>>(
// these two are already handled downstream in case of lazy normalization // these two are already handled downstream in case of lazy normalization
(&ty::Projection(a_data), &ty::Projection(b_data)) => { (&ty::Projection(a_data), &ty::Projection(b_data)) => {
let projection_ty = relation.relate(a_data, b_data)?; let projection_ty = relation.relate(a_data, b_data)?;
Ok(tcx.mk_projection(projection_ty.item_def_id, projection_ty.substs)) Ok(tcx.mk_projection(projection_ty.def_id, projection_ty.substs))
} }
( (

22
compiler/rustc_middle/src/ty/sty.rs
View file

@ -693,7 +693,7 @@ impl<'tcx> ExistentialPredicate<'tcx> {
match (*self, *other) { match (*self, *other) {
(Trait(_), Trait(_)) => Ordering::Equal, (Trait(_), Trait(_)) => Ordering::Equal,
(Projection(ref a), Projection(ref b)) => { (Projection(ref a), Projection(ref b)) => {
tcx.def_path_hash(a.item_def_id).cmp(&tcx.def_path_hash(b.item_def_id)) tcx.def_path_hash(a.def_id).cmp(&tcx.def_path_hash(b.def_id))
} }
(AutoTrait(ref a), AutoTrait(ref b)) => { (AutoTrait(ref a), AutoTrait(ref b)) => {
tcx.def_path_hash(*a).cmp(&tcx.def_path_hash(*b)) tcx.def_path_hash(*a).cmp(&tcx.def_path_hash(*b))
@ -1152,15 +1152,15 @@ pub struct ProjectionTy<'tcx> {
/// Note that this is not the `DefId` of the `TraitRef` containing this /// Note that this is not the `DefId` of the `TraitRef` containing this
/// associated type, which is in `tcx.associated_item(item_def_id).container`, /// associated type, which is in `tcx.associated_item(item_def_id).container`,
/// aka. `tcx.parent(item_def_id).unwrap()`. /// aka. `tcx.parent(item_def_id).unwrap()`.
pub item_def_id: DefId, pub def_id: DefId,
} }
impl<'tcx> ProjectionTy<'tcx> { impl<'tcx> ProjectionTy<'tcx> {
pub fn trait_def_id(&self, tcx: TyCtxt<'tcx>) -> DefId { pub fn trait_def_id(&self, tcx: TyCtxt<'tcx>) -> DefId {
match tcx.def_kind(self.item_def_id) { match tcx.def_kind(self.def_id) {
DefKind::AssocTy | DefKind::AssocConst => tcx.parent(self.item_def_id), DefKind::AssocTy | DefKind::AssocConst => tcx.parent(self.def_id),
DefKind::ImplTraitPlaceholder => { DefKind::ImplTraitPlaceholder => {
tcx.parent(tcx.impl_trait_in_trait_parent(self.item_def_id)) tcx.parent(tcx.impl_trait_in_trait_parent(self.def_id))
} }
kind => bug!("unexpected DefKind in ProjectionTy: {kind:?}"), kind => bug!("unexpected DefKind in ProjectionTy: {kind:?}"),
} }
@ -1173,7 +1173,7 @@ impl<'tcx> ProjectionTy<'tcx> {
&self, &self,
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
) -> (ty::TraitRef<'tcx>, &'tcx [ty::GenericArg<'tcx>]) { ) -> (ty::TraitRef<'tcx>, &'tcx [ty::GenericArg<'tcx>]) {
let def_id = tcx.parent(self.item_def_id); let def_id = tcx.parent(self.def_id);
assert_eq!(tcx.def_kind(def_id), DefKind::Trait); assert_eq!(tcx.def_kind(def_id), DefKind::Trait);
let trait_generics = tcx.generics_of(def_id); let trait_generics = tcx.generics_of(def_id);
( (
@ -1415,7 +1415,7 @@ impl From<BoundVar> for BoundTy {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]
#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)] #[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
pub struct ExistentialProjection<'tcx> { pub struct ExistentialProjection<'tcx> {
pub item_def_id: DefId, pub def_id: DefId,
pub substs: SubstsRef<'tcx>, pub substs: SubstsRef<'tcx>,
pub term: Term<'tcx>, pub term: Term<'tcx>,
} }
@ -1428,7 +1428,7 @@ impl<'tcx> ExistentialProjection<'tcx> {
/// then this function would return an `exists T. T: Iterator` existential trait /// then this function would return an `exists T. T: Iterator` existential trait
/// reference. /// reference.
pub fn trait_ref(&self, tcx: TyCtxt<'tcx>) -> ty::ExistentialTraitRef<'tcx> { pub fn trait_ref(&self, tcx: TyCtxt<'tcx>) -> ty::ExistentialTraitRef<'tcx> {
let def_id = tcx.parent(self.item_def_id); let def_id = tcx.parent(self.def_id);
let subst_count = tcx.generics_of(def_id).count() - 1; let subst_count = tcx.generics_of(def_id).count() - 1;
let substs = tcx.intern_substs(&self.substs[..subst_count]); let substs = tcx.intern_substs(&self.substs[..subst_count]);
ty::ExistentialTraitRef { def_id, substs } ty::ExistentialTraitRef { def_id, substs }
@ -1444,7 +1444,7 @@ impl<'tcx> ExistentialProjection<'tcx> {
ty::ProjectionPredicate { ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { projection_ty: ty::ProjectionTy {
item_def_id: self.item_def_id, def_id: self.def_id,
substs: tcx.mk_substs_trait(self_ty, self.substs), substs: tcx.mk_substs_trait(self_ty, self.substs),
}, },
term: self.term, term: self.term,
@ -1459,7 +1459,7 @@ impl<'tcx> ExistentialProjection<'tcx> {
projection_predicate.projection_ty.substs.type_at(0); projection_predicate.projection_ty.substs.type_at(0);
Self { Self {
item_def_id: projection_predicate.projection_ty.item_def_id, def_id: projection_predicate.projection_ty.def_id,
substs: tcx.intern_substs(&projection_predicate.projection_ty.substs[1..]), substs: tcx.intern_substs(&projection_predicate.projection_ty.substs[1..]),
term: projection_predicate.term, term: projection_predicate.term,
} }
@ -1476,7 +1476,7 @@ impl<'tcx> PolyExistentialProjection<'tcx> {
} }
pub fn item_def_id(&self) -> DefId { pub fn item_def_id(&self) -> DefId {
self.skip_binder().item_def_id self.skip_binder().def_id
} }
} }

4
compiler/rustc_privacy/src/lib.rs
View file

@ -123,13 +123,13 @@ where
projection: ty::ProjectionTy<'tcx>, projection: ty::ProjectionTy<'tcx>,
) -> ControlFlow<V::BreakTy> { ) -> ControlFlow<V::BreakTy> {
let tcx = self.def_id_visitor.tcx(); let tcx = self.def_id_visitor.tcx();
let (trait_ref, assoc_substs) = if tcx.def_kind(projection.item_def_id) let (trait_ref, assoc_substs) = if tcx.def_kind(projection.def_id)
!= DefKind::ImplTraitPlaceholder != DefKind::ImplTraitPlaceholder
{ {
projection.trait_ref_and_own_substs(tcx) projection.trait_ref_and_own_substs(tcx)
} else { } else {
// HACK(RPITIT): Remove this when RPITITs are lowered to regular assoc tys // HACK(RPITIT): Remove this when RPITITs are lowered to regular assoc tys
let def_id = tcx.impl_trait_in_trait_parent(projection.item_def_id); let def_id = tcx.impl_trait_in_trait_parent(projection.def_id);
let trait_generics = tcx.generics_of(def_id); let trait_generics = tcx.generics_of(def_id);
( (
ty::TraitRef { def_id, substs: projection.substs.truncate_to(tcx, trait_generics) }, ty::TraitRef { def_id, substs: projection.substs.truncate_to(tcx, trait_generics) },

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

@ -217,7 +217,7 @@ impl<'tcx> Printer<'tcx> for &mut SymbolPrinter<'tcx> {
// Print all nominal types as paths (unlike `pretty_print_type`). // Print all nominal types as paths (unlike `pretty_print_type`).
ty::FnDef(def_id, substs) ty::FnDef(def_id, substs)
| ty::Opaque(ty::OpaqueTy { def_id, substs }) | ty::Opaque(ty::OpaqueTy { def_id, substs })
| ty::Projection(ty::ProjectionTy { item_def_id: def_id, substs }) | ty::Projection(ty::ProjectionTy { def_id, substs })
| ty::Closure(def_id, substs) | ty::Closure(def_id, substs)
| ty::Generator(def_id, substs, _) => self.print_def_path(def_id, substs), | ty::Generator(def_id, substs, _) => self.print_def_path(def_id, substs),

2
compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
View file

@ -240,7 +240,7 @@ fn encode_predicate<'tcx>(
s.push_str(&encode_substs(tcx, trait_ref.substs, dict, options)); s.push_str(&encode_substs(tcx, trait_ref.substs, dict, options));
} }
ty::ExistentialPredicate::Projection(projection) => { ty::ExistentialPredicate::Projection(projection) => {
let name = encode_ty_name(tcx, projection.item_def_id); let name = encode_ty_name(tcx, projection.def_id);
let _ = write!(s, "u{}{}", name.len(), &name); let _ = write!(s, "u{}{}", name.len(), &name);
s.push_str(&encode_substs(tcx, projection.substs, dict, options)); s.push_str(&encode_substs(tcx, projection.substs, dict, options));
match projection.term.unpack() { match projection.term.unpack() {

4
compiler/rustc_symbol_mangling/src/v0.rs
View file

@ -440,7 +440,7 @@ impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx> {
ty::Adt(ty::AdtDef(Interned(&ty::AdtDefData { did: def_id, .. }, _)), substs) ty::Adt(ty::AdtDef(Interned(&ty::AdtDefData { did: def_id, .. }, _)), substs)
| ty::FnDef(def_id, substs) | ty::FnDef(def_id, substs)
| ty::Opaque(ty::OpaqueTy { def_id, substs }) | ty::Opaque(ty::OpaqueTy { def_id, substs })
| ty::Projection(ty::ProjectionTy { item_def_id: def_id, substs }) | ty::Projection(ty::ProjectionTy { def_id, substs })
| ty::Closure(def_id, substs) | ty::Closure(def_id, substs)
| ty::Generator(def_id, substs, _) => { | ty::Generator(def_id, substs, _) => {
self = self.print_def_path(def_id, substs)?; self = self.print_def_path(def_id, substs)?;
@ -544,7 +544,7 @@ impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx> {
cx = cx.print_def_path(trait_ref.def_id, trait_ref.substs)?; cx = cx.print_def_path(trait_ref.def_id, trait_ref.substs)?;
} }
ty::ExistentialPredicate::Projection(projection) => { ty::ExistentialPredicate::Projection(projection) => {
let name = cx.tcx.associated_item(projection.item_def_id).name; let name = cx.tcx.associated_item(projection.def_id).name;
cx.push("p"); cx.push("p");
cx.push_ident(name.as_str()); cx.push_ident(name.as_str());
cx = match projection.term.unpack() { cx = match projection.term.unpack() {

9
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -1634,8 +1634,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let normalized_ty = ocx.normalize( let normalized_ty = ocx.normalize(
&obligation.cause, &obligation.cause,
obligation.param_env, obligation.param_env,
self.tcx self.tcx.mk_projection(data.projection_ty.def_id, data.projection_ty.substs),
.mk_projection(data.projection_ty.item_def_id, data.projection_ty.substs),
); );
debug!(?obligation.cause, ?obligation.param_env); debug!(?obligation.cause, ?obligation.param_env);
@ -1686,10 +1685,10 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let secondary_span = match predicate.kind().skip_binder() { let secondary_span = match predicate.kind().skip_binder() {
ty::PredicateKind::Clause(ty::Clause::Projection(proj)) => self ty::PredicateKind::Clause(ty::Clause::Projection(proj)) => self
.tcx .tcx
.opt_associated_item(proj.projection_ty.item_def_id) .opt_associated_item(proj.projection_ty.def_id)
.and_then(|trait_assoc_item| { .and_then(|trait_assoc_item| {
self.tcx self.tcx
.trait_of_item(proj.projection_ty.item_def_id) .trait_of_item(proj.projection_ty.def_id)
.map(|id| (trait_assoc_item, id)) .map(|id| (trait_assoc_item, id))
}) })
.and_then(|(trait_assoc_item, id)| { .and_then(|(trait_assoc_item, id)| {
@ -1745,7 +1744,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
let trait_def_id = pred.projection_ty.trait_def_id(self.tcx); let trait_def_id = pred.projection_ty.trait_def_id(self.tcx);
let self_ty = pred.projection_ty.self_ty(); let self_ty = pred.projection_ty.self_ty();
if Some(pred.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output() { if Some(pred.projection_ty.def_id) == self.tcx.lang_items().fn_once_output() {
Some(format!( Some(format!(
"expected `{self_ty}` to be a {fn_kind} that returns `{expected_ty}`, but it returns `{normalized_ty}`", "expected `{self_ty}` to be a {fn_kind} that returns `{expected_ty}`, but it returns `{normalized_ty}`",
fn_kind = self_ty.prefix_string(self.tcx) fn_kind = self_ty.prefix_string(self.tcx)

10
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -858,7 +858,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
ty::Opaque(ty::OpaqueTy { def_id, substs }) => { ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
self.tcx.bound_item_bounds(def_id).subst(self.tcx, substs).iter().find_map(|pred| { self.tcx.bound_item_bounds(def_id).subst(self.tcx, substs).iter().find_map(|pred| {
if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder() if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder()
&& Some(proj.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output() && Some(proj.projection_ty.def_id) == self.tcx.lang_items().fn_once_output()
// args tuple will always be substs[1] // args tuple will always be substs[1]
&& let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind() && let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind()
{ {
@ -875,7 +875,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
ty::Dynamic(data, _, ty::Dyn) => { ty::Dynamic(data, _, ty::Dyn) => {
data.iter().find_map(|pred| { data.iter().find_map(|pred| {
if let ty::ExistentialPredicate::Projection(proj) = pred.skip_binder() if let ty::ExistentialPredicate::Projection(proj) = pred.skip_binder()
&& Some(proj.item_def_id) == self.tcx.lang_items().fn_once_output() && Some(proj.def_id) == self.tcx.lang_items().fn_once_output()
// for existential projection, substs are shifted over by 1 // for existential projection, substs are shifted over by 1
&& let ty::Tuple(args) = proj.substs.type_at(0).kind() && let ty::Tuple(args) = proj.substs.type_at(0).kind()
{ {
@ -892,7 +892,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
ty::Param(_) => { ty::Param(_) => {
obligation.param_env.caller_bounds().iter().find_map(|pred| { obligation.param_env.caller_bounds().iter().find_map(|pred| {
if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder() if let ty::PredicateKind::Clause(ty::Clause::Projection(proj)) = pred.kind().skip_binder()
&& Some(proj.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output() && Some(proj.projection_ty.def_id) == self.tcx.lang_items().fn_once_output()
&& proj.projection_ty.self_ty() == found && proj.projection_ty.self_ty() == found
// args tuple will always be substs[1] // args tuple will always be substs[1]
&& let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind() && let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind()
@ -3248,7 +3248,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
// This corresponds to `<ExprTy as Iterator>::Item = _`. // This corresponds to `<ExprTy as Iterator>::Item = _`.
let trait_ref = ty::Binder::dummy(ty::PredicateKind::Clause( let trait_ref = ty::Binder::dummy(ty::PredicateKind::Clause(
ty::Clause::Projection(ty::ProjectionPredicate { ty::Clause::Projection(ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { substs, item_def_id: proj.item_def_id }, projection_ty: ty::ProjectionTy { substs, def_id: proj.def_id },
term: ty_var.into(), term: ty_var.into(),
}), }),
)); ));
@ -3263,7 +3263,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if ocx.select_where_possible().is_empty() { if ocx.select_where_possible().is_empty() {
// `ty_var` now holds the type that `Item` is for `ExprTy`. // `ty_var` now holds the type that `Item` is for `ExprTy`.
let ty_var = self.resolve_vars_if_possible(ty_var); let ty_var = self.resolve_vars_if_possible(ty_var);
assocs_in_this_method.push(Some((span, (proj.item_def_id, ty_var)))); assocs_in_this_method.push(Some((span, (proj.def_id, ty_var))));
} else { } else {
// `<ExprTy as Iterator>` didn't select, so likely we've // `<ExprTy as Iterator>` didn't select, so likely we've
// reached the end of the iterator chain, like the originating // reached the end of the iterator chain, like the originating

8
compiler/rustc_trait_selection/src/traits/object_safety.rs
View file

@ -589,7 +589,7 @@ fn object_ty_for_trait<'tcx>(
let pred = obligation.predicate.to_opt_poly_projection_pred()?; let pred = obligation.predicate.to_opt_poly_projection_pred()?;
Some(pred.map_bound(|p| { Some(pred.map_bound(|p| {
ty::ExistentialPredicate::Projection(ty::ExistentialProjection { ty::ExistentialPredicate::Projection(ty::ExistentialProjection {
item_def_id: p.projection_ty.item_def_id, def_id: p.projection_ty.def_id,
substs: p.projection_ty.substs, substs: p.projection_ty.substs,
term: p.term, term: p.term,
}) })
@ -795,7 +795,7 @@ fn contains_illegal_self_type_reference<'tcx, T: TypeVisitable<'tcx>>(
} }
} }
ty::Projection(ref data) ty::Projection(ref data)
if self.tcx.def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder => if self.tcx.def_kind(data.def_id) == DefKind::ImplTraitPlaceholder =>
{ {
// We'll deny these later in their own pass // We'll deny these later in their own pass
ControlFlow::CONTINUE ControlFlow::CONTINUE
@ -862,9 +862,9 @@ pub fn contains_illegal_impl_trait_in_trait<'tcx>(
ty.skip_binder().walk().find_map(|arg| { ty.skip_binder().walk().find_map(|arg| {
if let ty::GenericArgKind::Type(ty) = arg.unpack() if let ty::GenericArgKind::Type(ty) = arg.unpack()
&& let ty::Projection(proj) = ty.kind() && let ty::Projection(proj) = ty.kind()
&& tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder && tcx.def_kind(proj.def_id) == DefKind::ImplTraitPlaceholder
{ {
Some(MethodViolationCode::ReferencesImplTraitInTrait(tcx.def_span(proj.item_def_id))) Some(MethodViolationCode::ReferencesImplTraitInTrait(tcx.def_span(proj.def_id)))
} else { } else {
None None
} }

61
compiler/rustc_trait_selection/src/traits/project.rs
View file

@ -1189,10 +1189,9 @@ fn normalize_to_error<'a, 'tcx>(
predicate: trait_ref.without_const().to_predicate(selcx.tcx()), predicate: trait_ref.without_const().to_predicate(selcx.tcx()),
}; };
let tcx = selcx.infcx.tcx; let tcx = selcx.infcx.tcx;
let def_id = projection_ty.item_def_id;
let new_value = selcx.infcx.next_ty_var(TypeVariableOrigin { let new_value = selcx.infcx.next_ty_var(TypeVariableOrigin {
kind: TypeVariableOriginKind::NormalizeProjectionType, kind: TypeVariableOriginKind::NormalizeProjectionType,
span: tcx.def_span(def_id), span: tcx.def_span(projection_ty.def_id),
}); });
Normalized { value: new_value, obligations: vec![trait_obligation] } Normalized { value: new_value, obligations: vec![trait_obligation] }
} }
@ -1270,7 +1269,7 @@ fn project<'cx, 'tcx>(
// need to investigate whether or not this is fine. // need to investigate whether or not this is fine.
selcx selcx
.tcx() .tcx()
.mk_projection(obligation.predicate.item_def_id, obligation.predicate.substs) .mk_projection(obligation.predicate.def_id, obligation.predicate.substs)
.into(), .into(),
)), )),
// Error occurred while trying to processing impls. // Error occurred while trying to processing impls.
@ -1290,13 +1289,12 @@ fn assemble_candidate_for_impl_trait_in_trait<'cx, 'tcx>(
candidate_set: &mut ProjectionCandidateSet<'tcx>, candidate_set: &mut ProjectionCandidateSet<'tcx>,
) { ) {
let tcx = selcx.tcx(); let tcx = selcx.tcx();
if tcx.def_kind(obligation.predicate.item_def_id) == DefKind::ImplTraitPlaceholder { if tcx.def_kind(obligation.predicate.def_id) == DefKind::ImplTraitPlaceholder {
let trait_fn_def_id = tcx.impl_trait_in_trait_parent(obligation.predicate.item_def_id); let trait_fn_def_id = tcx.impl_trait_in_trait_parent(obligation.predicate.def_id);
// If we are trying to project an RPITIT with trait's default `Self` parameter, // If we are trying to project an RPITIT with trait's default `Self` parameter,
// then we must be within a default trait body. // then we must be within a default trait body.
if obligation.predicate.self_ty() if obligation.predicate.self_ty()
== ty::InternalSubsts::identity_for_item(tcx, obligation.predicate.item_def_id) == ty::InternalSubsts::identity_for_item(tcx, obligation.predicate.def_id).type_at(0)
.type_at(0)
&& tcx.associated_item(trait_fn_def_id).defaultness(tcx).has_value() && tcx.associated_item(trait_fn_def_id).defaultness(tcx).has_value()
{ {
candidate_set.push_candidate(ProjectionCandidate::ImplTraitInTrait( candidate_set.push_candidate(ProjectionCandidate::ImplTraitInTrait(
@ -1377,7 +1375,7 @@ fn assemble_candidates_from_trait_def<'cx, 'tcx>(
// Check whether the self-type is itself a projection. // Check whether the self-type is itself a projection.
// If so, extract what we know from the trait and try to come up with a good answer. // If so, extract what we know from the trait and try to come up with a good answer.
let bounds = match *obligation.predicate.self_ty().kind() { let bounds = match *obligation.predicate.self_ty().kind() {
ty::Projection(ref data) => tcx.bound_item_bounds(data.item_def_id).subst(tcx, data.substs), ty::Projection(ref data) => tcx.bound_item_bounds(data.def_id).subst(tcx, data.substs),
ty::Opaque(ty::OpaqueTy { def_id, substs }) => { ty::Opaque(ty::OpaqueTy { def_id, substs }) => {
tcx.bound_item_bounds(def_id).subst(tcx, substs) tcx.bound_item_bounds(def_id).subst(tcx, substs)
} }
@ -1432,7 +1430,7 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
}; };
let env_predicates = data let env_predicates = data
.projection_bounds() .projection_bounds()
.filter(|bound| bound.item_def_id() == obligation.predicate.item_def_id) .filter(|bound| bound.item_def_id() == obligation.predicate.def_id)
.map(|p| p.with_self_ty(tcx, object_ty).to_predicate(tcx)); .map(|p| p.with_self_ty(tcx, object_ty).to_predicate(tcx));
assemble_candidates_from_predicates( assemble_candidates_from_predicates(
@ -1464,7 +1462,7 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
predicate.kind().skip_binder() predicate.kind().skip_binder()
{ {
let data = bound_predicate.rebind(data); let data = bound_predicate.rebind(data);
if data.projection_def_id() != obligation.predicate.item_def_id { if data.projection_def_id() != obligation.predicate.def_id {
continue; continue;
} }
@ -1505,7 +1503,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
candidate_set: &mut ProjectionCandidateSet<'tcx>, candidate_set: &mut ProjectionCandidateSet<'tcx>,
) { ) {
// Can't assemble candidate from impl for RPITIT // Can't assemble candidate from impl for RPITIT
if selcx.tcx().def_kind(obligation.predicate.item_def_id) == DefKind::ImplTraitPlaceholder { if selcx.tcx().def_kind(obligation.predicate.def_id) == DefKind::ImplTraitPlaceholder {
return; return;
} }
@ -1557,7 +1555,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
// NOTE: This should be kept in sync with the similar code in // NOTE: This should be kept in sync with the similar code in
// `rustc_ty_utils::instance::resolve_associated_item()`. // `rustc_ty_utils::instance::resolve_associated_item()`.
let node_item = let node_item =
assoc_def(selcx, impl_data.impl_def_id, obligation.predicate.item_def_id) assoc_def(selcx, impl_data.impl_def_id, obligation.predicate.def_id)
.map_err(|ErrorGuaranteed { .. }| ())?; .map_err(|ErrorGuaranteed { .. }| ())?;
if node_item.is_final() { if node_item.is_final() {
@ -1790,7 +1788,7 @@ fn confirm_candidate<'cx, 'tcx>(
ProjectionCandidate::ImplTraitInTrait(ImplTraitInTraitCandidate::Trait) => Progress { ProjectionCandidate::ImplTraitInTrait(ImplTraitInTraitCandidate::Trait) => Progress {
term: selcx term: selcx
.tcx() .tcx()
.mk_opaque(obligation.predicate.item_def_id, obligation.predicate.substs) .mk_opaque(obligation.predicate.def_id, obligation.predicate.substs)
.into(), .into(),
obligations: vec![], obligations: vec![],
}, },
@ -1862,7 +1860,7 @@ fn confirm_generator_candidate<'cx, 'tcx>(
gen_sig, gen_sig,
) )
.map_bound(|(trait_ref, yield_ty, return_ty)| { .map_bound(|(trait_ref, yield_ty, return_ty)| {
let name = tcx.associated_item(obligation.predicate.item_def_id).name; let name = tcx.associated_item(obligation.predicate.def_id).name;
let ty = if name == sym::Return { let ty = if name == sym::Return {
return_ty return_ty
} else if name == sym::Yield { } else if name == sym::Yield {
@ -1874,7 +1872,7 @@ fn confirm_generator_candidate<'cx, 'tcx>(
ty::ProjectionPredicate { ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { projection_ty: ty::ProjectionTy {
substs: trait_ref.substs, substs: trait_ref.substs,
item_def_id: obligation.predicate.item_def_id, def_id: obligation.predicate.def_id,
}, },
term: ty.into(), term: ty.into(),
} }
@ -1911,12 +1909,12 @@ fn confirm_future_candidate<'cx, 'tcx>(
gen_sig, gen_sig,
) )
.map_bound(|(trait_ref, return_ty)| { .map_bound(|(trait_ref, return_ty)| {
debug_assert_eq!(tcx.associated_item(obligation.predicate.item_def_id).name, sym::Output); debug_assert_eq!(tcx.associated_item(obligation.predicate.def_id).name, sym::Output);
ty::ProjectionPredicate { ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { projection_ty: ty::ProjectionTy {
substs: trait_ref.substs, substs: trait_ref.substs,
item_def_id: obligation.predicate.item_def_id, def_id: obligation.predicate.def_id,
}, },
term: return_ty.into(), term: return_ty.into(),
} }
@ -1936,7 +1934,7 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
let self_ty = obligation.predicate.self_ty(); let self_ty = obligation.predicate.self_ty();
let substs = tcx.mk_substs([self_ty.into()].iter()); let substs = tcx.mk_substs([self_ty.into()].iter());
let lang_items = tcx.lang_items(); let lang_items = tcx.lang_items();
let item_def_id = obligation.predicate.item_def_id; let item_def_id = obligation.predicate.def_id;
let trait_def_id = tcx.trait_of_item(item_def_id).unwrap(); let trait_def_id = tcx.trait_of_item(item_def_id).unwrap();
let (term, obligations) = if lang_items.discriminant_kind_trait() == Some(trait_def_id) { let (term, obligations) = if lang_items.discriminant_kind_trait() == Some(trait_def_id) {
let discriminant_def_id = tcx.require_lang_item(LangItem::Discriminant, None); let discriminant_def_id = tcx.require_lang_item(LangItem::Discriminant, None);
@ -1970,8 +1968,10 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
bug!("unexpected builtin trait with associated type: {:?}", obligation.predicate); bug!("unexpected builtin trait with associated type: {:?}", obligation.predicate);
}; };
let predicate = let predicate = ty::ProjectionPredicate {
ty::ProjectionPredicate { projection_ty: ty::ProjectionTy { substs, item_def_id }, term }; projection_ty: ty::ProjectionTy { substs, def_id: item_def_id },
term,
};
confirm_param_env_candidate(selcx, obligation, ty::Binder::dummy(predicate), false) confirm_param_env_candidate(selcx, obligation, ty::Binder::dummy(predicate), false)
.with_addl_obligations(obligations) .with_addl_obligations(obligations)
@ -2040,10 +2040,7 @@ fn confirm_callable_candidate<'cx, 'tcx>(
flag, flag,
) )
.map_bound(|(trait_ref, ret_type)| ty::ProjectionPredicate { .map_bound(|(trait_ref, ret_type)| ty::ProjectionPredicate {
projection_ty: ty::ProjectionTy { projection_ty: ty::ProjectionTy { substs: trait_ref.substs, def_id: fn_once_output_def_id },
substs: trait_ref.substs,
item_def_id: fn_once_output_def_id,
},
term: ret_type.into(), term: ret_type.into(),
}); });
@ -2124,7 +2121,7 @@ fn confirm_impl_candidate<'cx, 'tcx>(
let tcx = selcx.tcx(); let tcx = selcx.tcx();
let ImplSourceUserDefinedData { impl_def_id, substs, mut nested } = impl_impl_source; let ImplSourceUserDefinedData { impl_def_id, substs, mut nested } = impl_impl_source;
let assoc_item_id = obligation.predicate.item_def_id; let assoc_item_id = obligation.predicate.def_id;
let trait_def_id = tcx.trait_id_of_impl(impl_def_id).unwrap(); let trait_def_id = tcx.trait_id_of_impl(impl_def_id).unwrap();
let param_env = obligation.param_env; let param_env = obligation.param_env;
@ -2224,7 +2221,7 @@ fn confirm_impl_trait_in_trait_candidate<'tcx>(
let tcx = selcx.tcx(); let tcx = selcx.tcx();
let mut obligations = data.nested; let mut obligations = data.nested;
let trait_fn_def_id = tcx.impl_trait_in_trait_parent(obligation.predicate.item_def_id); let trait_fn_def_id = tcx.impl_trait_in_trait_parent(obligation.predicate.def_id);
let Ok(leaf_def) = assoc_def(selcx, data.impl_def_id, trait_fn_def_id) else { let Ok(leaf_def) = assoc_def(selcx, data.impl_def_id, trait_fn_def_id) else {
return Progress { term: tcx.ty_error().into(), obligations }; return Progress { term: tcx.ty_error().into(), obligations };
}; };
@ -2235,9 +2232,7 @@ fn confirm_impl_trait_in_trait_candidate<'tcx>(
// Use the default `impl Trait` for the trait, e.g., for a default trait body // Use the default `impl Trait` for the trait, e.g., for a default trait body
if leaf_def.item.container == ty::AssocItemContainer::TraitContainer { if leaf_def.item.container == ty::AssocItemContainer::TraitContainer {
return Progress { return Progress {
term: tcx term: tcx.mk_opaque(obligation.predicate.def_id, obligation.predicate.substs).into(),
.mk_opaque(obligation.predicate.item_def_id, obligation.predicate.substs)
.into(),
obligations, obligations,
}; };
} }
@ -2304,7 +2299,7 @@ fn confirm_impl_trait_in_trait_candidate<'tcx>(
obligation.recursion_depth + 1, obligation.recursion_depth + 1,
tcx.bound_trait_impl_trait_tys(impl_fn_def_id) tcx.bound_trait_impl_trait_tys(impl_fn_def_id)
.map_bound(|tys| { .map_bound(|tys| {
tys.map_or_else(|_| tcx.ty_error(), |tys| tys[&obligation.predicate.item_def_id]) tys.map_or_else(|_| tcx.ty_error(), |tys| tys[&obligation.predicate.def_id])
}) })
.subst(tcx, impl_fn_substs), .subst(tcx, impl_fn_substs),
&mut obligations, &mut obligations,
@ -2322,7 +2317,7 @@ fn assoc_ty_own_obligations<'cx, 'tcx>(
) { ) {
let tcx = selcx.tcx(); let tcx = selcx.tcx();
let own = tcx let own = tcx
.predicates_of(obligation.predicate.item_def_id) .predicates_of(obligation.predicate.def_id)
.instantiate_own(tcx, obligation.predicate.substs); .instantiate_own(tcx, obligation.predicate.substs);
for (predicate, span) in std::iter::zip(own.predicates, own.spans) { for (predicate, span) in std::iter::zip(own.predicates, own.spans) {
let normalized = normalize_with_depth_to( let normalized = normalize_with_depth_to(
@ -2345,13 +2340,13 @@ fn assoc_ty_own_obligations<'cx, 'tcx>(
ObligationCause::new( ObligationCause::new(
obligation.cause.span, obligation.cause.span,
obligation.cause.body_id, obligation.cause.body_id,
super::ItemObligation(obligation.predicate.item_def_id), super::ItemObligation(obligation.predicate.def_id),
) )
} else { } else {
ObligationCause::new( ObligationCause::new(
obligation.cause.span, obligation.cause.span,
obligation.cause.body_id, obligation.cause.body_id,
super::BindingObligation(obligation.predicate.item_def_id, span), super::BindingObligation(obligation.predicate.def_id, span),
) )
}; };
nested.push(Obligation::with_depth( nested.push(Obligation::with_depth(

2
compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
View file

@ -537,7 +537,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self, self,
param_env, param_env,
ty::ProjectionTy { ty::ProjectionTy {
item_def_id: tcx.lang_items().deref_target()?, def_id: tcx.lang_items().deref_target()?,
substs: trait_ref.substs, substs: trait_ref.substs,
}, },
cause.clone(), cause.clone(),

2
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View file

@ -155,7 +155,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let placeholder_self_ty = placeholder_trait_predicate.self_ty(); let placeholder_self_ty = placeholder_trait_predicate.self_ty();
let placeholder_trait_predicate = ty::Binder::dummy(placeholder_trait_predicate); let placeholder_trait_predicate = ty::Binder::dummy(placeholder_trait_predicate);
let (def_id, substs) = match *placeholder_self_ty.kind() { let (def_id, substs) = match *placeholder_self_ty.kind() {
ty::Projection(proj) => (proj.item_def_id, proj.substs), ty::Projection(proj) => (proj.def_id, proj.substs),
ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs), ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs),
_ => bug!("projection candidate for unexpected type: {:?}", placeholder_self_ty), _ => bug!("projection candidate for unexpected type: {:?}", placeholder_self_ty),
}; };

4
compiler/rustc_trait_selection/src/traits/select/mod.rs
View file

@ -1595,7 +1595,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let tcx = self.infcx.tcx; let tcx = self.infcx.tcx;
let (def_id, substs) = match *placeholder_trait_predicate.trait_ref.self_ty().kind() { let (def_id, substs) = match *placeholder_trait_predicate.trait_ref.self_ty().kind() {
ty::Projection(ref data) => (data.item_def_id, data.substs), ty::Projection(ref data) => (data.def_id, data.substs),
ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs), ty::Opaque(ty::OpaqueTy { def_id, substs }) => (def_id, substs),
_ => { _ => {
span_bug!( span_bug!(
@ -1745,7 +1745,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
}); });
if is_match { if is_match {
let generics = self.tcx().generics_of(obligation.predicate.item_def_id); let generics = self.tcx().generics_of(obligation.predicate.def_id);
// FIXME(generic-associated-types): Addresses aggressive inference in #92917. // FIXME(generic-associated-types): Addresses aggressive inference in #92917.
// If this type is a GAT, and of the GAT substs resolve to something new, // If this type is a GAT, and of the GAT substs resolve to something new,
// that means that we must have newly inferred something about the GAT. // that means that we must have newly inferred something about the GAT.

8
compiler/rustc_trait_selection/src/traits/wf.rs
View file

@ -236,7 +236,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
// `traits-assoc-type-in-supertrait-bad.rs`. // `traits-assoc-type-in-supertrait-bad.rs`.
if let Some(ty::Projection(projection_ty)) = proj.term.ty().map(|ty| ty.kind()) if let Some(ty::Projection(projection_ty)) = proj.term.ty().map(|ty| ty.kind())
&& let Some(&impl_item_id) = && let Some(&impl_item_id) =
tcx.impl_item_implementor_ids(impl_def_id).get(&projection_ty.item_def_id) tcx.impl_item_implementor_ids(impl_def_id).get(&projection_ty.def_id)
&& let Some(impl_item_span) = items && let Some(impl_item_span) = items
.iter() .iter()
.find(|item| item.id.owner_id.to_def_id() == impl_item_id) .find(|item| item.id.owner_id.to_def_id() == impl_item_id)
@ -249,9 +249,9 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
// An associated item obligation born out of the `trait` failed to be met. An example // An associated item obligation born out of the `trait` failed to be met. An example
// can be seen in `ui/associated-types/point-at-type-on-obligation-failure-2.rs`. // can be seen in `ui/associated-types/point-at-type-on-obligation-failure-2.rs`.
debug!("extended_cause_with_original_assoc_item_obligation trait proj {:?}", pred); debug!("extended_cause_with_original_assoc_item_obligation trait proj {:?}", pred);
if let ty::Projection(ty::ProjectionTy { item_def_id, .. }) = *pred.self_ty().kind() if let ty::Projection(ty::ProjectionTy { def_id, .. }) = *pred.self_ty().kind()
&& let Some(&impl_item_id) = && let Some(&impl_item_id) =
tcx.impl_item_implementor_ids(impl_def_id).get(&item_def_id) tcx.impl_item_implementor_ids(impl_def_id).get(&def_id)
&& let Some(impl_item_span) = items && let Some(impl_item_span) = items
.iter() .iter()
.find(|item| item.id.owner_id.to_def_id() == impl_item_id) .find(|item| item.id.owner_id.to_def_id() == impl_item_id)
@ -392,7 +392,7 @@ impl<'tcx> WfPredicates<'tcx> {
// `i32: Copy` // `i32: Copy`
// ] // ]
// Projection types do not require const predicates. // Projection types do not require const predicates.
let obligations = self.nominal_obligations_without_const(data.item_def_id, data.substs); let obligations = self.nominal_obligations_without_const(data.def_id, data.substs);
self.out.extend(obligations); self.out.extend(obligations);
let tcx = self.tcx(); let tcx = self.tcx();

10
compiler/rustc_traits/src/chalk/lowering.rs
View file

@ -69,7 +69,7 @@ impl<'tcx> LowerInto<'tcx, SubstsRef<'tcx>> for &chalk_ir::Substitution<RustInte
impl<'tcx> LowerInto<'tcx, chalk_ir::AliasTy<RustInterner<'tcx>>> for ty::ProjectionTy<'tcx> { impl<'tcx> LowerInto<'tcx, chalk_ir::AliasTy<RustInterner<'tcx>>> for ty::ProjectionTy<'tcx> {
fn lower_into(self, interner: RustInterner<'tcx>) -> chalk_ir::AliasTy<RustInterner<'tcx>> { fn lower_into(self, interner: RustInterner<'tcx>) -> chalk_ir::AliasTy<RustInterner<'tcx>> {
chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
associated_ty_id: chalk_ir::AssocTypeId(self.item_def_id), associated_ty_id: chalk_ir::AssocTypeId(self.def_id),
substitution: self.substs.lower_into(interner), substitution: self.substs.lower_into(interner),
}) })
} }
@ -448,7 +448,7 @@ impl<'tcx> LowerInto<'tcx, Ty<'tcx>> for &chalk_ir::Ty<RustInterner<'tcx>> {
}), }),
TyKind::AssociatedType(assoc_ty, substitution) => ty::Projection(ty::ProjectionTy { TyKind::AssociatedType(assoc_ty, substitution) => ty::Projection(ty::ProjectionTy {
substs: substitution.lower_into(interner), substs: substitution.lower_into(interner),
item_def_id: assoc_ty.0, def_id: assoc_ty.0,
}), }),
TyKind::Foreign(def_id) => ty::Foreign(def_id.0), TyKind::Foreign(def_id) => ty::Foreign(def_id.0),
TyKind::Error => return interner.tcx.ty_error(), TyKind::Error => return interner.tcx.ty_error(),
@ -458,7 +458,7 @@ impl<'tcx> LowerInto<'tcx, Ty<'tcx>> for &chalk_ir::Ty<RustInterner<'tcx>> {
}), }),
TyKind::Alias(alias_ty) => match alias_ty { TyKind::Alias(alias_ty) => match alias_ty {
chalk_ir::AliasTy::Projection(projection) => ty::Projection(ty::ProjectionTy { chalk_ir::AliasTy::Projection(projection) => ty::Projection(ty::ProjectionTy {
item_def_id: projection.associated_ty_id.0, def_id: projection.associated_ty_id.0,
substs: projection.substitution.lower_into(interner), substs: projection.substitution.lower_into(interner),
}), }),
chalk_ir::AliasTy::Opaque(opaque) => ty::Opaque(ty::OpaqueTy { chalk_ir::AliasTy::Opaque(opaque) => ty::Opaque(ty::OpaqueTy {
@ -690,7 +690,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Binders<chalk_ir::QuantifiedWhereClauses<Ru
binders.clone(), binders.clone(),
chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq {
alias: chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy { alias: chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
associated_ty_id: chalk_ir::AssocTypeId(predicate.item_def_id), associated_ty_id: chalk_ir::AssocTypeId(predicate.def_id),
substitution: interner substitution: interner
.tcx .tcx
.mk_substs_trait(self_ty, predicate.substs) .mk_substs_trait(self_ty, predicate.substs)
@ -846,7 +846,7 @@ impl<'tcx> LowerInto<'tcx, chalk_solve::rust_ir::AliasEqBound<RustInterner<'tcx>
let (trait_ref, own_substs) = self.projection_ty.trait_ref_and_own_substs(interner.tcx); let (trait_ref, own_substs) = self.projection_ty.trait_ref_and_own_substs(interner.tcx);
chalk_solve::rust_ir::AliasEqBound { chalk_solve::rust_ir::AliasEqBound {
trait_bound: trait_ref.lower_into(interner), trait_bound: trait_ref.lower_into(interner),
associated_ty_id: chalk_ir::AssocTypeId(self.projection_ty.item_def_id), associated_ty_id: chalk_ir::AssocTypeId(self.projection_ty.def_id),
parameters: own_substs.iter().map(|arg| arg.lower_into(interner)).collect(), parameters: own_substs.iter().map(|arg| arg.lower_into(interner)).collect(),
value: self.term.ty().unwrap().lower_into(interner), value: self.term.ty().unwrap().lower_into(interner),
} }

3
compiler/rustc_type_ir/src/sty.rs
View file

@ -170,8 +170,7 @@ pub enum TyKind<I: Interner> {
/// A tuple type. For example, `(i32, bool)`. /// A tuple type. For example, `(i32, bool)`.
Tuple(I::ListTy), Tuple(I::ListTy),
/// The projection of an associated type. For example, /// A projection or opaque type. Both of these types
/// `<T as Trait<..>>::N`.
Projection(I::ProjectionTy), Projection(I::ProjectionTy),
/// Opaque (`impl Trait`) type found in a return type. /// Opaque (`impl Trait`) type found in a return type.

8
src/librustdoc/clean/mod.rs
View file

@ -418,10 +418,10 @@ fn clean_projection<'tcx>(
cx: &mut DocContext<'tcx>, cx: &mut DocContext<'tcx>,
def_id: Option<DefId>, def_id: Option<DefId>,
) -> Type { ) -> Type {
if cx.tcx.def_kind(ty.skip_binder().item_def_id) == DefKind::ImplTraitPlaceholder { if cx.tcx.def_kind(ty.skip_binder().def_id) == DefKind::ImplTraitPlaceholder {
let bounds = cx let bounds = cx
.tcx .tcx
.explicit_item_bounds(ty.skip_binder().item_def_id) .explicit_item_bounds(ty.skip_binder().def_id)
.iter() .iter()
.map(|(bound, _)| EarlyBinder(*bound).subst(cx.tcx, ty.skip_binder().substs)) .map(|(bound, _)| EarlyBinder(*bound).subst(cx.tcx, ty.skip_binder().substs))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
@ -456,8 +456,8 @@ fn projection_to_path_segment<'tcx>(
ty: ty::Binder<'tcx, ty::ProjectionTy<'tcx>>, ty: ty::Binder<'tcx, ty::ProjectionTy<'tcx>>,
cx: &mut DocContext<'tcx>, cx: &mut DocContext<'tcx>,
) -> PathSegment { ) -> PathSegment {
let item = cx.tcx.associated_item(ty.skip_binder().item_def_id); let item = cx.tcx.associated_item(ty.skip_binder().def_id);
let generics = cx.tcx.generics_of(ty.skip_binder().item_def_id); let generics = cx.tcx.generics_of(ty.skip_binder().def_id);
PathSegment { PathSegment {
name: item.name, name: item.name,
args: GenericArgs::AngleBracketed { args: GenericArgs::AngleBracketed {

2
src/tools/clippy/clippy_lints/src/dereference.rs
View file

@ -1330,7 +1330,7 @@ fn replace_types<'tcx>(
&& let Some(term_ty) = projection_predicate.term.ty() && let Some(term_ty) = projection_predicate.term.ty()
&& let ty::Param(term_param_ty) = term_ty.kind() && let ty::Param(term_param_ty) = term_ty.kind()
{ {
let item_def_id = projection_predicate.projection_ty.item_def_id; let item_def_id = projection_predicate.projection_ty.def_id;
let assoc_item = cx.tcx.associated_item(item_def_id); let assoc_item = cx.tcx.associated_item(item_def_id);
let projection = cx.tcx let projection = cx.tcx
.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(new_ty, [])); .mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(new_ty, []));

2
src/tools/clippy/clippy_lints/src/len_zero.rs
View file

@ -493,7 +493,7 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
.filter_by_name_unhygienic(is_empty) .filter_by_name_unhygienic(is_empty)
.any(|item| is_is_empty(cx, item)) .any(|item| is_is_empty(cx, item))
}), }),
ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id), ty::Projection(ref proj) => has_is_empty_impl(cx, proj.def_id),
ty::Adt(id, _) => has_is_empty_impl(cx, id.did()), ty::Adt(id, _) => has_is_empty_impl(cx, id.did()),
ty::Array(..) | ty::Slice(..) | ty::Str => true, ty::Array(..) | ty::Slice(..) | ty::Str => true,
_ => false, _ => false,

2
src/tools/clippy/clippy_lints/src/methods/needless_collect.rs
View file

@ -151,7 +151,7 @@ fn iterates_same_ty<'tcx>(cx: &LateContext<'tcx>, iter_ty: Ty<'tcx>, collect_ty:
&& let Some(into_iter_item_proj) = make_projection(cx.tcx, into_iter_trait, item, [collect_ty]) && let Some(into_iter_item_proj) = make_projection(cx.tcx, into_iter_trait, item, [collect_ty])
&& let Ok(into_iter_item_ty) = cx.tcx.try_normalize_erasing_regions( && let Ok(into_iter_item_ty) = cx.tcx.try_normalize_erasing_regions(
cx.param_env, cx.param_env,
cx.tcx.mk_projection(into_iter_item_proj.item_def_id, into_iter_item_proj.substs) cx.tcx.mk_projection(into_iter_item_proj.def_id, into_iter_item_proj.substs)
) )
{ {
iter_item_ty == into_iter_item_ty iter_item_ty == into_iter_item_ty

10
src/tools/clippy/clippy_utils/src/ty.rs
View file

@ -685,7 +685,7 @@ fn sig_from_bounds<'tcx>(
inputs = Some(i); inputs = Some(i);
}, },
PredicateKind::Clause(ty::Clause::Projection(p)) PredicateKind::Clause(ty::Clause::Projection(p))
if Some(p.projection_ty.item_def_id) == lang_items.fn_once_output() if Some(p.projection_ty.def_id) == lang_items.fn_once_output()
&& p.projection_ty.self_ty() == ty => && p.projection_ty.self_ty() == ty =>
{ {
if output.is_some() { if output.is_some() {
@ -708,7 +708,7 @@ fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: ProjectionTy<'tcx>) -> O
for (pred, _) in cx for (pred, _) in cx
.tcx .tcx
.bound_explicit_item_bounds(ty.item_def_id) .bound_explicit_item_bounds(ty.def_id)
.subst_iter_copied(cx.tcx, ty.substs) .subst_iter_copied(cx.tcx, ty.substs)
{ {
match pred.kind().skip_binder() { match pred.kind().skip_binder() {
@ -726,7 +726,7 @@ fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: ProjectionTy<'tcx>) -> O
inputs = Some(i); inputs = Some(i);
}, },
PredicateKind::Clause(ty::Clause::Projection(p)) PredicateKind::Clause(ty::Clause::Projection(p))
if Some(p.projection_ty.item_def_id) == lang_items.fn_once_output() => if Some(p.projection_ty.def_id) == lang_items.fn_once_output() =>
{ {
if output.is_some() { if output.is_some() {
// Multiple different fn trait impls. Is this even allowed? // Multiple different fn trait impls. Is this even allowed?
@ -1041,7 +1041,7 @@ pub fn make_projection<'tcx>(
Some(ProjectionTy { Some(ProjectionTy {
substs, substs,
item_def_id: assoc_item.def_id, def_id: assoc_item.def_id,
}) })
} }
helper( helper(
@ -1081,7 +1081,7 @@ pub fn make_normalized_projection<'tcx>(
); );
return None; return None;
} }
match tcx.try_normalize_erasing_regions(param_env, tcx.mk_projection(ty.item_def_id, ty.substs)) { match tcx.try_normalize_erasing_regions(param_env, tcx.mk_projection(ty.def_id, ty.substs)) {
Ok(ty) => Some(ty), Ok(ty) => Some(ty),
Err(e) => { Err(e) => {
debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}"); debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}");