diff options
Diffstat (limited to 'compiler/rustc_next_trait_solver/src/solve')
6 files changed, 88 insertions, 80 deletions
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs index a4a8317912a..be7e4dd4cda 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs @@ -7,7 +7,7 @@ use std::ops::ControlFlow; use derive_where::derive_where; use rustc_type_ir::inherent::*; -use rustc_type_ir::lang_items::TraitSolverLangItem; +use rustc_type_ir::lang_items::SolverTraitLangItem; use rustc_type_ir::search_graph::CandidateHeadUsages; use rustc_type_ir::solve::SizedTraitKind; use rustc_type_ir::{ @@ -54,7 +54,7 @@ where fn with_replaced_self_ty(self, cx: I, self_ty: I::Ty) -> Self; - fn trait_def_id(self, cx: I) -> I::DefId; + fn trait_def_id(self, cx: I) -> I::TraitId; /// Consider a clause, which consists of a "assumption" and some "requirements", /// to satisfy a goal. If the requirements hold, then attempt to satisfy our @@ -516,80 +516,80 @@ where } else if cx.trait_is_alias(trait_def_id) { G::consider_trait_alias_candidate(self, goal) } else { - match cx.as_lang_item(trait_def_id) { - Some(TraitSolverLangItem::Sized) => { + match cx.as_trait_lang_item(trait_def_id) { + Some(SolverTraitLangItem::Sized) => { G::consider_builtin_sizedness_candidates(self, goal, SizedTraitKind::Sized) } - Some(TraitSolverLangItem::MetaSized) => { + Some(SolverTraitLangItem::MetaSized) => { G::consider_builtin_sizedness_candidates(self, goal, SizedTraitKind::MetaSized) } - Some(TraitSolverLangItem::PointeeSized) => { + Some(SolverTraitLangItem::PointeeSized) => { unreachable!("`PointeeSized` is removed during lowering"); } - Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => { + Some(SolverTraitLangItem::Copy | SolverTraitLangItem::Clone) => { G::consider_builtin_copy_clone_candidate(self, goal) } - Some(TraitSolverLangItem::Fn) => { + Some(SolverTraitLangItem::Fn) => { G::consider_builtin_fn_trait_candidates(self, goal, ty::ClosureKind::Fn) } - Some(TraitSolverLangItem::FnMut) => { + Some(SolverTraitLangItem::FnMut) => { G::consider_builtin_fn_trait_candidates(self, goal, ty::ClosureKind::FnMut) } - Some(TraitSolverLangItem::FnOnce) => { + Some(SolverTraitLangItem::FnOnce) => { G::consider_builtin_fn_trait_candidates(self, goal, ty::ClosureKind::FnOnce) } - Some(TraitSolverLangItem::AsyncFn) => { + Some(SolverTraitLangItem::AsyncFn) => { G::consider_builtin_async_fn_trait_candidates(self, goal, ty::ClosureKind::Fn) } - Some(TraitSolverLangItem::AsyncFnMut) => { + Some(SolverTraitLangItem::AsyncFnMut) => { G::consider_builtin_async_fn_trait_candidates( self, goal, ty::ClosureKind::FnMut, ) } - Some(TraitSolverLangItem::AsyncFnOnce) => { + Some(SolverTraitLangItem::AsyncFnOnce) => { G::consider_builtin_async_fn_trait_candidates( self, goal, ty::ClosureKind::FnOnce, ) } - Some(TraitSolverLangItem::FnPtrTrait) => { + Some(SolverTraitLangItem::FnPtrTrait) => { G::consider_builtin_fn_ptr_trait_candidate(self, goal) } - Some(TraitSolverLangItem::AsyncFnKindHelper) => { + Some(SolverTraitLangItem::AsyncFnKindHelper) => { G::consider_builtin_async_fn_kind_helper_candidate(self, goal) } - Some(TraitSolverLangItem::Tuple) => G::consider_builtin_tuple_candidate(self, goal), - Some(TraitSolverLangItem::PointeeTrait) => { + Some(SolverTraitLangItem::Tuple) => G::consider_builtin_tuple_candidate(self, goal), + Some(SolverTraitLangItem::PointeeTrait) => { G::consider_builtin_pointee_candidate(self, goal) } - Some(TraitSolverLangItem::Future) => { + Some(SolverTraitLangItem::Future) => { G::consider_builtin_future_candidate(self, goal) } - Some(TraitSolverLangItem::Iterator) => { + Some(SolverTraitLangItem::Iterator) => { G::consider_builtin_iterator_candidate(self, goal) } - Some(TraitSolverLangItem::FusedIterator) => { + Some(SolverTraitLangItem::FusedIterator) => { G::consider_builtin_fused_iterator_candidate(self, goal) } - Some(TraitSolverLangItem::AsyncIterator) => { + Some(SolverTraitLangItem::AsyncIterator) => { G::consider_builtin_async_iterator_candidate(self, goal) } - Some(TraitSolverLangItem::Coroutine) => { + Some(SolverTraitLangItem::Coroutine) => { G::consider_builtin_coroutine_candidate(self, goal) } - Some(TraitSolverLangItem::DiscriminantKind) => { + Some(SolverTraitLangItem::DiscriminantKind) => { G::consider_builtin_discriminant_kind_candidate(self, goal) } - Some(TraitSolverLangItem::Destruct) => { + Some(SolverTraitLangItem::Destruct) => { G::consider_builtin_destruct_candidate(self, goal) } - Some(TraitSolverLangItem::TransmuteTrait) => { + Some(SolverTraitLangItem::TransmuteTrait) => { G::consider_builtin_transmute_candidate(self, goal) } - Some(TraitSolverLangItem::BikeshedGuaranteedNoDrop) => { + Some(SolverTraitLangItem::BikeshedGuaranteedNoDrop) => { G::consider_builtin_bikeshed_guaranteed_no_drop_candidate(self, goal) } _ => Err(NoSolution), @@ -600,7 +600,7 @@ where // There may be multiple unsize candidates for a trait with several supertraits: // `trait Foo: Bar<A> + Bar<B>` and `dyn Foo: Unsize<dyn Bar<_>>` - if cx.is_lang_item(trait_def_id, TraitSolverLangItem::Unsize) { + if cx.is_trait_lang_item(trait_def_id, SolverTraitLangItem::Unsize) { candidates.extend(G::consider_structural_builtin_unsize_candidates(self, goal)); } } diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs index d25e74e7335..7c5940828da 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs @@ -4,7 +4,7 @@ use derive_where::derive_where; use rustc_type_ir::data_structures::HashMap; use rustc_type_ir::inherent::*; -use rustc_type_ir::lang_items::TraitSolverLangItem; +use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem}; use rustc_type_ir::solve::SizedTraitKind; use rustc_type_ir::solve::inspect::ProbeKind; use rustc_type_ir::{ @@ -454,7 +454,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I: nested.push( ty::TraitRef::new( cx, - cx.require_lang_item(TraitSolverLangItem::AsyncFnKindHelper), + cx.require_trait_lang_item(SolverTraitLangItem::AsyncFnKindHelper), [kind_ty, Ty::from_closure_kind(cx, goal_kind)], ) .upcast(cx), @@ -496,7 +496,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I: let args = args.as_closure(); let bound_sig = args.sig(); let sig = bound_sig.skip_binder(); - let future_trait_def_id = cx.require_lang_item(TraitSolverLangItem::Future); + let future_trait_def_id = cx.require_trait_lang_item(SolverTraitLangItem::Future); // `Closure`s only implement `AsyncFn*` when their return type // implements `Future`. let mut nested = vec![ @@ -514,7 +514,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I: } } else { let async_fn_kind_trait_def_id = - cx.require_lang_item(TraitSolverLangItem::AsyncFnKindHelper); + cx.require_trait_lang_item(SolverTraitLangItem::AsyncFnKindHelper); // When we don't know the closure kind (and therefore also the closure's upvars, // which are computed at the same time), we must delay the computation of the // generator's upvars. We do this using the `AsyncFnKindHelper`, which as a trait @@ -532,7 +532,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I: ); } - let future_output_def_id = cx.require_lang_item(TraitSolverLangItem::FutureOutput); + let future_output_def_id = cx.require_lang_item(SolverLangItem::FutureOutput); let future_output_ty = Ty::new_projection(cx, future_output_def_id, [sig.output()]); Ok(( bound_sig.rebind(AsyncCallableRelevantTypes { @@ -581,13 +581,13 @@ fn fn_item_to_async_callable<I: Interner>( bound_sig: ty::Binder<I, ty::FnSig<I>>, ) -> Result<(ty::Binder<I, AsyncCallableRelevantTypes<I>>, Vec<I::Predicate>), NoSolution> { let sig = bound_sig.skip_binder(); - let future_trait_def_id = cx.require_lang_item(TraitSolverLangItem::Future); + let future_trait_def_id = cx.require_trait_lang_item(SolverTraitLangItem::Future); // `FnDef` and `FnPtr` only implement `AsyncFn*` when their // return type implements `Future`. let nested = vec![ bound_sig.rebind(ty::TraitRef::new(cx, future_trait_def_id, [sig.output()])).upcast(cx), ]; - let future_output_def_id = cx.require_lang_item(TraitSolverLangItem::FutureOutput); + let future_output_def_id = cx.require_lang_item(SolverLangItem::FutureOutput); let future_output_ty = Ty::new_projection(cx, future_output_def_id, [sig.output()]); Ok(( bound_sig.rebind(AsyncCallableRelevantTypes { @@ -633,7 +633,7 @@ fn coroutine_closure_to_ambiguous_coroutine<I: Interner>( args: ty::CoroutineClosureArgs<I>, sig: ty::CoroutineClosureSignature<I>, ) -> I::Ty { - let upvars_projection_def_id = cx.require_lang_item(TraitSolverLangItem::AsyncFnKindUpvars); + let upvars_projection_def_id = cx.require_lang_item(SolverLangItem::AsyncFnKindUpvars); let tupled_upvars_ty = Ty::new_projection( cx, upvars_projection_def_id, @@ -732,7 +732,7 @@ pub(in crate::solve) fn const_conditions_for_destruct<I: Interner>( cx: I, self_ty: I::Ty, ) -> Result<Vec<ty::TraitRef<I>>, NoSolution> { - let destruct_def_id = cx.require_lang_item(TraitSolverLangItem::Destruct); + let destruct_def_id = cx.require_trait_lang_item(SolverTraitLangItem::Destruct); match self_ty.kind() { // `ManuallyDrop` is trivially `[const] Destruct` as we do not run any drop glue on it. @@ -751,7 +751,7 @@ pub(in crate::solve) fn const_conditions_for_destruct<I: Interner>( Some(AdtDestructorKind::NotConst) => return Err(NoSolution), // `Drop` impl exists, and it's const. Require `Ty: [const] Drop` to hold. Some(AdtDestructorKind::Const) => { - let drop_def_id = cx.require_lang_item(TraitSolverLangItem::Drop); + let drop_def_id = cx.require_trait_lang_item(SolverTraitLangItem::Drop); let drop_trait_ref = ty::TraitRef::new(cx, drop_def_id, [self_ty]); const_conditions.push(drop_trait_ref); } @@ -869,7 +869,7 @@ where // FIXME(associated_const_equality): Also add associated consts to // the requirements here. - for associated_type_def_id in cx.associated_type_def_ids(trait_ref.def_id) { + for associated_type_def_id in cx.associated_type_def_ids(trait_ref.def_id.into()) { // associated types that require `Self: Sized` do not show up in the built-in // implementation of `Trait for dyn Trait`, and can be dropped here. if cx.generics_require_sized_self(associated_type_def_id) { diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs index b7ae9994c62..229345065b1 100644 --- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs @@ -3,7 +3,7 @@ use rustc_type_ir::fast_reject::DeepRejectCtxt; use rustc_type_ir::inherent::*; -use rustc_type_ir::lang_items::TraitSolverLangItem; +use rustc_type_ir::lang_items::SolverTraitLangItem; use rustc_type_ir::solve::SizedTraitKind; use rustc_type_ir::solve::inspect::ProbeKind; use rustc_type_ir::{self as ty, Interner, TypingMode, elaborate}; @@ -33,7 +33,7 @@ where self.with_replaced_self_ty(cx, self_ty) } - fn trait_def_id(self, _: I) -> I::DefId { + fn trait_def_id(self, _: I) -> I::TraitId { self.def_id() } @@ -237,7 +237,7 @@ where // A built-in `Fn` impl only holds if the output is sized. // (FIXME: technically we only need to check this if the type is a fn ptr...) let output_is_sized_pred = inputs_and_output.map_bound(|(_, output)| { - ty::TraitRef::new(cx, cx.require_lang_item(TraitSolverLangItem::Sized), [output]) + ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]) }); let requirements = cx .const_conditions(def_id) diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs index c2745c878dc..710b59f662a 100644 --- a/compiler/rustc_next_trait_solver/src/solve/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs @@ -130,7 +130,7 @@ where } } - fn compute_dyn_compatible_goal(&mut self, trait_def_id: I::DefId) -> QueryResult<I> { + fn compute_dyn_compatible_goal(&mut self, trait_def_id: I::TraitId) -> QueryResult<I> { if self.cx().trait_is_dyn_compatible(trait_def_id) { self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) } else { diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs index 93434dce79f..cfdf2007391 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs @@ -5,7 +5,7 @@ mod opaque_types; use rustc_type_ir::fast_reject::DeepRejectCtxt; use rustc_type_ir::inherent::*; -use rustc_type_ir::lang_items::TraitSolverLangItem; +use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem}; use rustc_type_ir::solve::SizedTraitKind; use rustc_type_ir::{self as ty, Interner, NormalizesTo, PredicateKind, Upcast as _}; use tracing::instrument; @@ -103,7 +103,7 @@ where self.with_replaced_self_ty(cx, self_ty) } - fn trait_def_id(self, cx: I) -> I::DefId { + fn trait_def_id(self, cx: I) -> I::TraitId { self.trait_def_id(cx) } @@ -456,7 +456,7 @@ where // A built-in `Fn` impl only holds if the output is sized. // (FIXME: technically we only need to check this if the type is a fn ptr...) let output_is_sized_pred = tupled_inputs_and_output.map_bound(|(_, output)| { - ty::TraitRef::new(cx, cx.require_lang_item(TraitSolverLangItem::Sized), [output]) + ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]) }); let pred = tupled_inputs_and_output @@ -503,7 +503,11 @@ where // (FIXME: technically we only need to check this if the type is a fn ptr...) let output_is_sized_pred = tupled_inputs_and_output_and_coroutine.map_bound( |AsyncCallableRelevantTypes { output_coroutine_ty: output_ty, .. }| { - ty::TraitRef::new(cx, cx.require_lang_item(TraitSolverLangItem::Sized), [output_ty]) + ty::TraitRef::new( + cx, + cx.require_trait_lang_item(SolverTraitLangItem::Sized), + [output_ty], + ) }, ); @@ -515,7 +519,7 @@ where coroutine_return_ty, }| { let (projection_term, term) = if cx - .is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::CallOnceFuture) + .is_lang_item(goal.predicate.def_id(), SolverLangItem::CallOnceFuture) { ( ty::AliasTerm::new( @@ -526,7 +530,7 @@ where output_coroutine_ty.into(), ) } else if cx - .is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::CallRefFuture) + .is_lang_item(goal.predicate.def_id(), SolverLangItem::CallRefFuture) { ( ty::AliasTerm::new( @@ -540,10 +544,9 @@ where ), output_coroutine_ty.into(), ) - } else if cx.is_lang_item( - goal.predicate.def_id(), - TraitSolverLangItem::AsyncFnOnceOutput, - ) { + } else if cx + .is_lang_item(goal.predicate.def_id(), SolverLangItem::AsyncFnOnceOutput) + { ( ty::AliasTerm::new( cx, @@ -637,7 +640,7 @@ where goal: Goal<I, Self>, ) -> Result<Candidate<I>, NoSolution> { let cx = ecx.cx(); - let metadata_def_id = cx.require_lang_item(TraitSolverLangItem::Metadata); + let metadata_def_id = cx.require_lang_item(SolverLangItem::Metadata); assert_eq!(metadata_def_id, goal.predicate.def_id()); let metadata_ty = match goal.predicate.self_ty().kind() { ty::Bool @@ -664,7 +667,7 @@ where ty::Str | ty::Slice(_) => Ty::new_usize(cx), ty::Dynamic(_, _, ty::Dyn) => { - let dyn_metadata = cx.require_lang_item(TraitSolverLangItem::DynMetadata); + let dyn_metadata = cx.require_lang_item(SolverLangItem::DynMetadata); cx.type_of(dyn_metadata) .instantiate(cx, &[I::GenericArg::from(goal.predicate.self_ty())]) } @@ -678,7 +681,7 @@ where ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { let sized_predicate = ty::TraitRef::new( cx, - cx.require_lang_item(TraitSolverLangItem::Sized), + cx.require_trait_lang_item(SolverTraitLangItem::Sized), [I::GenericArg::from(goal.predicate.self_ty())], ); ecx.add_goal(GoalSource::Misc, goal.with(cx, sized_predicate)); @@ -821,10 +824,10 @@ where // coroutine yield ty `Poll<Option<I>>`. let wrapped_expected_ty = Ty::new_adt( cx, - cx.adt_def(cx.require_lang_item(TraitSolverLangItem::Poll)), + cx.adt_def(cx.require_lang_item(SolverLangItem::Poll)), cx.mk_args(&[Ty::new_adt( cx, - cx.adt_def(cx.require_lang_item(TraitSolverLangItem::Option)), + cx.adt_def(cx.require_lang_item(SolverLangItem::Option)), cx.mk_args(&[expected_ty.into()]), ) .into()]), @@ -853,10 +856,9 @@ where let coroutine = args.as_coroutine(); - let term = if cx.is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::CoroutineReturn) - { + let term = if cx.is_lang_item(goal.predicate.def_id(), SolverLangItem::CoroutineReturn) { coroutine.return_ty().into() - } else if cx.is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::CoroutineYield) { + } else if cx.is_lang_item(goal.predicate.def_id(), SolverLangItem::CoroutineYield) { coroutine.yield_ty().into() } else { panic!("unexpected associated item `{:?}` for `{self_ty:?}`", goal.predicate.def_id()) @@ -983,13 +985,13 @@ where target_container_def_id: I::DefId, ) -> Result<I::GenericArgs, NoSolution> { let cx = self.cx(); - Ok(if target_container_def_id == impl_trait_ref.def_id { + Ok(if target_container_def_id == impl_trait_ref.def_id.into() { // Default value from the trait definition. No need to rebase. goal.predicate.alias.args } else if target_container_def_id == impl_def_id { // Same impl, no need to fully translate, just a rebase from // the trait is sufficient. - goal.predicate.alias.args.rebase_onto(cx, impl_trait_ref.def_id, impl_args) + goal.predicate.alias.args.rebase_onto(cx, impl_trait_ref.def_id.into(), impl_args) } else { let target_args = self.fresh_args_for_item(target_container_def_id); let target_trait_ref = @@ -1004,7 +1006,7 @@ where .iter_instantiated(cx, target_args) .map(|pred| goal.with(cx, pred)), ); - goal.predicate.alias.args.rebase_onto(cx, impl_trait_ref.def_id, target_args) + goal.predicate.alias.args.rebase_onto(cx, impl_trait_ref.def_id.into(), target_args) }) } } diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs index 891ecab041a..cdcfebf2909 100644 --- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs @@ -3,7 +3,7 @@ use rustc_type_ir::data_structures::IndexSet; use rustc_type_ir::fast_reject::DeepRejectCtxt; use rustc_type_ir::inherent::*; -use rustc_type_ir::lang_items::TraitSolverLangItem; +use rustc_type_ir::lang_items::SolverTraitLangItem; use rustc_type_ir::solve::{CanonicalResponse, SizedTraitKind}; use rustc_type_ir::{ self as ty, Interner, Movability, PredicatePolarity, TraitPredicate, TraitRef, @@ -39,7 +39,7 @@ where self.with_replaced_self_ty(cx, self_ty) } - fn trait_def_id(self, _: I) -> I::DefId { + fn trait_def_id(self, _: I) -> I::TraitId { self.def_id() } @@ -131,8 +131,8 @@ where ) -> Result<(), NoSolution> { fn trait_def_id_matches<I: Interner>( cx: I, - clause_def_id: I::DefId, - goal_def_id: I::DefId, + clause_def_id: I::TraitId, + goal_def_id: I::TraitId, polarity: PredicatePolarity, ) -> bool { clause_def_id == goal_def_id @@ -141,8 +141,8 @@ where // // `PointeeSized` bounds are syntactic sugar for a lack of bounds so don't need this. || (polarity == PredicatePolarity::Positive - && cx.is_lang_item(clause_def_id, TraitSolverLangItem::Sized) - && cx.is_lang_item(goal_def_id, TraitSolverLangItem::MetaSized)) + && cx.is_trait_lang_item(clause_def_id, SolverTraitLangItem::Sized) + && cx.is_trait_lang_item(goal_def_id, SolverTraitLangItem::MetaSized)) } if let Some(trait_clause) = assumption.as_trait_clause() @@ -177,8 +177,8 @@ where // are syntactic sugar for a lack of bounds so don't need this. // We don't need to check polarity, `fast_reject_assumption` already rejected non-`Positive` // polarity `Sized` assumptions as matching non-`Positive` `MetaSized` goals. - if ecx.cx().is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::MetaSized) - && ecx.cx().is_lang_item(trait_clause.def_id(), TraitSolverLangItem::Sized) + if ecx.cx().is_trait_lang_item(goal.predicate.def_id(), SolverTraitLangItem::MetaSized) + && ecx.cx().is_trait_lang_item(trait_clause.def_id(), SolverTraitLangItem::Sized) { let meta_sized_clause = trait_predicate_with_def_id(ecx.cx(), trait_clause, goal.predicate.def_id()); @@ -263,7 +263,7 @@ where ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { let nested_obligations = cx - .predicates_of(goal.predicate.def_id()) + .predicates_of(goal.predicate.def_id().into()) .iter_instantiated(cx, goal.predicate.trait_ref.args) .map(|p| goal.with(cx, p)); // While you could think of trait aliases to have a single builtin impl @@ -372,7 +372,7 @@ where // A built-in `Fn` impl only holds if the output is sized. // (FIXME: technically we only need to check this if the type is a fn ptr...) let output_is_sized_pred = tupled_inputs_and_output.map_bound(|(_, output)| { - ty::TraitRef::new(cx, cx.require_lang_item(TraitSolverLangItem::Sized), [output]) + ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]) }); let pred = tupled_inputs_and_output @@ -414,7 +414,7 @@ where |AsyncCallableRelevantTypes { output_coroutine_ty, .. }| { ty::TraitRef::new( cx, - cx.require_lang_item(TraitSolverLangItem::Sized), + cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output_coroutine_ty], ) }, @@ -757,7 +757,7 @@ where cx, ty::TraitRef::new( cx, - cx.require_lang_item(TraitSolverLangItem::Copy), + cx.require_trait_lang_item(SolverTraitLangItem::Copy), [ty], ), ), @@ -857,7 +857,7 @@ where fn trait_predicate_with_def_id<I: Interner>( cx: I, clause: ty::Binder<I, ty::TraitPredicate<I>>, - did: I::DefId, + did: I::TraitId, ) -> I::Clause { clause .map_bound(|c| TraitPredicate { @@ -956,7 +956,11 @@ where GoalSource::ImplWhereBound, goal.with( cx, - ty::TraitRef::new(cx, cx.require_lang_item(TraitSolverLangItem::Sized), [a_ty]), + ty::TraitRef::new( + cx, + cx.require_trait_lang_item(SolverTraitLangItem::Sized), + [a_ty], + ), ), ); @@ -981,7 +985,7 @@ where // We may upcast to auto traits that are either explicitly listed in // the object type's bounds, or implied by the principal trait ref's // supertraits. - let a_auto_traits: IndexSet<I::DefId> = a_data + let a_auto_traits: IndexSet<I::TraitId> = a_data .auto_traits() .into_iter() .chain(a_data.principal_def_id().into_iter().flat_map(|principal_def_id| { @@ -1143,7 +1147,7 @@ where cx, ty::TraitRef::new( cx, - cx.require_lang_item(TraitSolverLangItem::Unsize), + cx.require_trait_lang_item(SolverTraitLangItem::Unsize), [a_tail_ty, b_tail_ty], ), ), @@ -1208,7 +1212,9 @@ where // takes precedence over the structural auto trait candidate being // assembled. ty::Coroutine(def_id, _) - if self.cx().is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::Unpin) => + if self + .cx() + .is_trait_lang_item(goal.predicate.def_id(), SolverTraitLangItem::Unpin) => { match self.cx().coroutine_movability(def_id) { Movability::Static => Some(Err(NoSolution)), |