From f26cc349d9b22272b4de474f78ac7829777a0649 Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Fri, 21 Jun 2024 13:33:08 -0400 Subject: [PATCH 1/3] Split out IntoIterator and non-Iterator constructors for AliasTy/AliasTerm/TraitRef/projection --- .../rustc_hir_analysis/src/check/check.rs | 2 +- .../src/check/compare_impl_item.rs | 8 +++- .../rustc_hir_analysis/src/check/intrinsic.rs | 6 ++- compiler/rustc_hir_analysis/src/collect.rs | 4 +- .../src/collect/item_bounds.rs | 4 +- .../src/hir_ty_lowering/bounds.rs | 2 +- .../src/hir_ty_lowering/mod.rs | 13 +++--- compiler/rustc_hir_typeck/src/expr.rs | 6 ++- .../src/fn_ctxt/adjust_fulfillment_errors.rs | 2 +- compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs | 2 +- compiler/rustc_hir_typeck/src/method/mod.rs | 2 +- compiler/rustc_hir_typeck/src/method/probe.rs | 2 +- .../rustc_hir_typeck/src/method/suggest.rs | 2 +- .../nice_region_error/placeholder_error.rs | 4 +- .../src/opaque_hidden_inferred_bound.rs | 2 +- compiler/rustc_middle/src/ty/context.rs | 10 ++--- compiler/rustc_middle/src/ty/sty.rs | 13 +++++- .../src/thir/pattern/const_to_pat.rs | 2 +- .../src/solve/eval_ctxt/mod.rs | 2 +- .../cfi/typeid/itanium_cxx_abi/transform.rs | 7 ++-- .../rustc_smir/src/rustc_internal/internal.rs | 2 +- .../src/traits/error_reporting/suggestions.rs | 6 +-- .../src/traits/object_safety.rs | 2 +- .../src/traits/project.rs | 40 ++++++++++++++----- .../src/traits/select/candidate_assembly.rs | 2 +- .../src/traits/select/mod.rs | 2 +- compiler/rustc_type_ir/src/inherent.rs | 8 ++++ compiler/rustc_type_ir/src/interner.rs | 6 +-- compiler/rustc_type_ir/src/predicate.rs | 30 ++++++++++---- compiler/rustc_type_ir/src/relate.rs | 6 +-- compiler/rustc_type_ir/src/ty_kind.rs | 13 ++++-- .../src/bool_assert_comparison.rs | 2 +- .../src/methods/needless_collect.rs | 4 +- .../clippy_lints/src/redundant_slicing.rs | 2 +- src/tools/clippy/clippy_utils/src/ty.rs | 8 ++-- 35 files changed, 144 insertions(+), 84 deletions(-) diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs index 3b53c253195fa..e13ea1a1935b4 100644 --- a/compiler/rustc_hir_analysis/src/check/check.rs +++ b/compiler/rustc_hir_analysis/src/check/check.rs @@ -719,7 +719,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) { tcx, assoc_item, assoc_item, - ty::TraitRef::new(tcx, def_id.to_def_id(), trait_args), + ty::TraitRef::new_from_args(tcx, def_id.to_def_id(), trait_args), ); } _ => {} diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs index 550f38af8b5da..7fa5c96bc9ab4 100644 --- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs +++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs @@ -2032,7 +2032,7 @@ pub(super) fn check_type_bounds<'tcx>( // to its definition type. This should be the param-env we use to *prove* the // predicate too, but we don't do that because of performance issues. // See . - let trait_projection_ty = Ty::new_projection(tcx, trait_ty.def_id, rebased_args); + let trait_projection_ty = Ty::new_projection_from_args(tcx, trait_ty.def_id, rebased_args); let impl_identity_ty = tcx.type_of(impl_ty.def_id).instantiate_identity(); let normalize_param_env = param_env_with_gat_bounds(tcx, impl_ty, impl_trait_ref); for mut obligation in util::elaborate(tcx, obligations) { @@ -2230,7 +2230,11 @@ fn param_env_with_gat_bounds<'tcx>( _ => predicates.push( ty::Binder::bind_with_vars( ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, trait_ty.def_id, rebased_args), + projection_term: ty::AliasTerm::new_from_args( + tcx, + trait_ty.def_id, + rebased_args, + ), term: normalize_impl_ty.into(), }, bound_vars, diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs index 683709f43f2db..f21aeb4c0b98c 100644 --- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs +++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs @@ -504,7 +504,11 @@ pub fn check_intrinsic_type( ty::Region::new_bound(tcx, ty::INNERMOST, br), param(0), )], - Ty::new_projection(tcx, discriminant_def_id, tcx.mk_args(&[param(0).into()])), + Ty::new_projection_from_args( + tcx, + discriminant_def_id, + tcx.mk_args(&[param(0).into()]), + ), ) } diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs index e5bd147352dea..e7892f1766067 100644 --- a/compiler/rustc_hir_analysis/src/collect.rs +++ b/compiler/rustc_hir_analysis/src/collect.rs @@ -423,7 +423,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> { item_segment, trait_ref.args, ); - Ty::new_projection(self.tcx(), item_def_id, item_args) + Ty::new_projection_from_args(self.tcx(), item_def_id, item_args) } else { // There are no late-bound regions; we can just ignore the binder. let (mut mpart_sugg, mut inferred_sugg) = (None, None); @@ -1607,7 +1607,7 @@ pub fn suggest_impl_trait<'tcx>( let item_ty = ocx.normalize( &ObligationCause::dummy(), param_env, - Ty::new_projection(infcx.tcx, assoc_item_def_id, args), + Ty::new_projection_from_args(infcx.tcx, assoc_item_def_id, args), ); // FIXME(compiler-errors): We may benefit from resolving regions here. if ocx.select_where_possible().is_empty() diff --git a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs index 9f198933dee4f..d084d3aefeb17 100644 --- a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs +++ b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs @@ -23,7 +23,7 @@ fn associated_type_bounds<'tcx>( span: Span, filter: PredicateFilter, ) -> &'tcx [(ty::Clause<'tcx>, Span)] { - let item_ty = Ty::new_projection( + let item_ty = Ty::new_projection_from_args( tcx, assoc_item_def_id.to_def_id(), GenericArgs::identity_for_item(tcx, assoc_item_def_id), @@ -108,7 +108,7 @@ pub(super) fn explicit_item_bounds_with_filter( tcx, opaque_def_id.expect_local(), opaque_ty.bounds, - Ty::new_projection( + Ty::new_projection_from_args( tcx, def_id.to_def_id(), ty::GenericArgs::identity_for_item(tcx, def_id), diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs index c7699b0b310fb..802215b2843ee 100644 --- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs +++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs @@ -409,7 +409,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { ); debug!(?alias_args); - ty::AliasTerm::new(tcx, assoc_item.def_id, alias_args) + ty::AliasTerm::new_from_args(tcx, assoc_item.def_id, alias_args) }); // Provide the resolved type of the associated constant to `type_of(AnonConst)`. diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs index 5911d5bb4e1e3..24ea328889c6b 100644 --- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs +++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs @@ -693,7 +693,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { debug!(?bound_vars); let poly_trait_ref = ty::Binder::bind_with_vars( - ty::TraitRef::new(tcx, trait_def_id, generic_args), + ty::TraitRef::new_from_args(tcx, trait_def_id, generic_args), bound_vars, ); @@ -759,7 +759,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { Some((trait_def_id, trait_segment, span)), ); } - ty::TraitRef::new(self.tcx(), trait_def_id, generic_args) + ty::TraitRef::new_from_args(self.tcx(), trait_def_id, generic_args) } fn probe_trait_that_defines_assoc_item( @@ -789,7 +789,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { // Type aliases defined in crates that have the // feature `lazy_type_alias` enabled get encoded as a type alias that normalization will // then actually instantiate the where bounds of. - let alias_ty = ty::AliasTy::new(tcx, did, args); + let alias_ty = ty::AliasTy::new_from_args(tcx, did, args); Ty::new_alias(tcx, ty::Weak, alias_ty) } else { tcx.at(span).type_of(did).instantiate(tcx, args) @@ -1267,7 +1267,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { .chain(args.into_iter().skip(parent_args.len())), ); - let ty = Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new(tcx, assoc_item, args)); + let ty = + Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new_from_args(tcx, assoc_item, args)); Ok(Some((ty, assoc_item))) } @@ -1534,7 +1535,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { let item_args = self.lower_generic_args_of_assoc_item(span, item_def_id, item_segment, trait_ref.args); - Ty::new_projection(tcx, item_def_id, item_args) + Ty::new_projection_from_args(tcx, item_def_id, item_args) } pub fn prohibit_generic_args<'a>( @@ -2302,7 +2303,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ { debug!(?args); if in_trait { - Ty::new_projection(tcx, def_id, args) + Ty::new_projection_from_args(tcx, def_id, args) } else { Ty::new_opaque(tcx, def_id, args) } diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs index 233dc2afa9b28..f4e1e46195345 100644 --- a/compiler/rustc_hir_typeck/src/expr.rs +++ b/compiler/rustc_hir_typeck/src/expr.rs @@ -3108,7 +3108,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let element_ty = ocx.normalize( &cause, self.param_env, - Ty::new_projection(self.tcx, index_trait_output_def_id, impl_trait_ref.args), + Ty::new_projection_from_args( + self.tcx, + index_trait_output_def_id, + impl_trait_ref.args, + ), ); let true_errors = ocx.select_where_possible(); diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs index 4edc11d7ab15b..f7abba357064d 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs +++ b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs @@ -569,7 +569,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // For the purposes of this function, we hope that it is a `struct` type, and that our current `expr` is a literal of // that struct type. let impl_trait_self_ref = if self.tcx.is_trait_alias(obligation.impl_or_alias_def_id) { - ty::TraitRef::new( + ty::TraitRef::new_from_args( self.tcx, obligation.impl_or_alias_def_id, ty::GenericArgs::identity_for_item(self.tcx, obligation.impl_or_alias_def_id), diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs index 1713d75092e2e..c0d604779677b 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs +++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs @@ -297,7 +297,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> { trait_ref.args, ); - Ty::new_projection(self.tcx(), item_def_id, item_args) + Ty::new_projection_from_args(self.tcx(), item_def_id, item_args) } fn probe_adt(&self, span: Span, ty: Ty<'tcx>) -> Option> { diff --git a/compiler/rustc_hir_typeck/src/method/mod.rs b/compiler/rustc_hir_typeck/src/method/mod.rs index 1f90d5e4c88ac..e1223307b53e3 100644 --- a/compiler/rustc_hir_typeck/src/method/mod.rs +++ b/compiler/rustc_hir_typeck/src/method/mod.rs @@ -333,7 +333,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { self.var_for_def(cause.span, param) }); - let trait_ref = ty::TraitRef::new(self.tcx, trait_def_id, args); + let trait_ref = ty::TraitRef::new_from_args(self.tcx, trait_def_id, args); // Construct an obligation let poly_trait_ref = ty::Binder::dummy(trait_ref); diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs index 47ea221d1a112..9747a91ccbfad 100644 --- a/compiler/rustc_hir_typeck/src/method/probe.rs +++ b/compiler/rustc_hir_typeck/src/method/probe.rs @@ -870,7 +870,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { trait_def_id: DefId, ) { let trait_args = self.fresh_args_for_item(self.span, trait_def_id); - let trait_ref = ty::TraitRef::new(self.tcx, trait_def_id, trait_args); + let trait_ref = ty::TraitRef::new_from_args(self.tcx, trait_def_id, trait_args); if self.tcx.is_trait_alias(trait_def_id) { // For trait aliases, recursively assume all explicitly named traits are relevant diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs index a5e955a986b95..4f46320fa0240 100644 --- a/compiler/rustc_hir_typeck/src/method/suggest.rs +++ b/compiler/rustc_hir_typeck/src/method/suggest.rs @@ -1978,7 +1978,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { err, self_source, args, - ty::TraitRef::new( + ty::TraitRef::new_from_args( self.tcx, trait_did, self.fresh_args_for_item(sugg_span, trait_did), diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs index e125f1858dde6..80b7e3b4fa509 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs @@ -256,12 +256,12 @@ impl<'tcx> NiceRegionError<'_, 'tcx> { (false, None, None, Some(span), String::new()) }; - let expected_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new( + let expected_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new_from_args( self.cx.tcx, trait_def_id, expected_args, )); - let actual_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new( + let actual_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new_from_args( self.cx.tcx, trait_def_id, actual_args, diff --git a/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs b/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs index 7aef6321eeb5d..8b669bcc13f0b 100644 --- a/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs +++ b/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs @@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound { return; } - let proj_ty = Ty::new_projection( + let proj_ty = Ty::new_projection_from_args( cx.tcx, proj.projection_term.def_id, proj.projection_term.args, diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 7848aa21eac9f..4bac9396e59a9 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -240,7 +240,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> { assert_matches!(self.def_kind(trait_def_id), DefKind::Trait); let trait_generics = self.generics_of(trait_def_id); ( - ty::TraitRef::new(self, trait_def_id, args.truncate_to(self, trait_generics)), + ty::TraitRef::new_from_args(self, trait_def_id, args.truncate_to(self, trait_generics)), &args[trait_generics.count()..], ) } @@ -261,12 +261,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> { self.check_args_compatible(def_id, args) } - fn check_and_mk_args( - self, - def_id: DefId, - args: impl IntoIterator>>, - ) -> ty::GenericArgsRef<'tcx> { - self.check_and_mk_args(def_id, args) + fn debug_assert_args_compatible(self, def_id: DefId, args: ty::GenericArgsRef<'tcx>) { + self.debug_assert_args_compatible(def_id, args); } fn intern_canonical_goal_evaluation_step( diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs index 9c8a3484aa5bd..a3cb84d561df3 100644 --- a/compiler/rustc_middle/src/ty/sty.rs +++ b/compiler/rustc_middle/src/ty/sty.rs @@ -499,7 +499,7 @@ impl<'tcx> Ty<'tcx> { #[inline] pub fn new_opaque(tcx: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>) -> Ty<'tcx> { - Ty::new_alias(tcx, ty::Opaque, AliasTy::new(tcx, def_id, args)) + Ty::new_alias(tcx, ty::Opaque, AliasTy::new_from_args(tcx, def_id, args)) } /// Constructs a `TyKind::Error` type with current `ErrorGuaranteed` @@ -669,6 +669,15 @@ impl<'tcx> Ty<'tcx> { Ty::new(tcx, Dynamic(obj, reg, repr)) } + #[inline] + pub fn new_projection_from_args( + tcx: TyCtxt<'tcx>, + item_def_id: DefId, + args: ty::GenericArgsRef<'tcx>, + ) -> Ty<'tcx> { + Ty::new_alias(tcx, ty::Projection, AliasTy::new_from_args(tcx, item_def_id, args)) + } + #[inline] pub fn new_projection( tcx: TyCtxt<'tcx>, @@ -1409,7 +1418,7 @@ impl<'tcx> Ty<'tcx> { let assoc_items = tcx.associated_item_def_ids( tcx.require_lang_item(hir::LangItem::DiscriminantKind, None), ); - Ty::new_projection(tcx, assoc_items[0], tcx.mk_args(&[self.into()])) + Ty::new_projection_from_args(tcx, assoc_items[0], tcx.mk_args(&[self.into()])) } ty::Pat(ty, _) => ty.discriminant_ty(tcx), diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs index dda6c88008bb0..8c6c9e10cdfdc 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs @@ -220,7 +220,7 @@ impl<'tcx> ConstToPat<'tcx> { tcx, ObligationCause::dummy(), self.param_env, - ty::TraitRef::new( + ty::TraitRef::new_from_args( tcx, partial_eq_trait_id, tcx.with_opt_host_effect_param( diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs index 6644fff2140c7..687623d440845 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs @@ -787,7 +787,7 @@ where // Alternatively we could modify `Equate` for this case by adding another // variant to `StructurallyRelateAliases`. let identity_args = self.fresh_args_for_item(alias.def_id); - let rigid_ctor = ty::AliasTerm::new(tcx, alias.def_id, identity_args); + let rigid_ctor = ty::AliasTerm::new_from_args(tcx, alias.def_id, identity_args); let ctor_term = rigid_ctor.to_term(tcx); let obligations = self.delegate.eq_structurally_relating_aliases(param_env, term, ctor_term)?; diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs index 44b31f2659c15..f0f2d1fefd2f3 100644 --- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs +++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs @@ -232,7 +232,8 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc .filter(|item| item.kind == ty::AssocKind::Type) .map(move |assoc_ty| { super_poly_trait_ref.map_bound(|super_trait_ref| { - let alias_ty = ty::AliasTy::new(tcx, assoc_ty.def_id, super_trait_ref.args); + let alias_ty = + ty::AliasTy::new_from_args(tcx, assoc_ty.def_id, super_trait_ref.args); let resolved = tcx.normalize_erasing_regions( ty::ParamEnv::reveal_all(), alias_ty.to_ty(tcx), @@ -351,7 +352,7 @@ pub fn transform_instance<'tcx>( // Adjust the type ids of VTableShims to the type id expected in the call sites for the // entry in the vtable (i.e., by using the signature of the closure passed as an argument // to the shim, or by just removing self). - let trait_ref = ty::TraitRef::new(tcx, trait_id, instance.args); + let trait_ref = ty::TraitRef::new_from_args(tcx, trait_id, instance.args); let invoke_ty = trait_object_ty(tcx, ty::Binder::dummy(trait_ref)); instance.args = tcx.mk_args_trait(invoke_ty, trait_ref.args.into_iter().skip(1)); } @@ -432,7 +433,7 @@ pub fn transform_instance<'tcx>( x => bug!("Unexpected type kind for closure-like: {x:?}"), }; let concrete_args = tcx.mk_args_trait(closure_ty, inputs.map(Into::into)); - let trait_ref = ty::TraitRef::new(tcx, trait_id, concrete_args); + let trait_ref = ty::TraitRef::new_from_args(tcx, trait_id, concrete_args); let invoke_ty = trait_object_ty(tcx, ty::Binder::dummy(trait_ref)); let abstract_args = tcx.mk_args_trait(invoke_ty, trait_ref.args.into_iter().skip(1)); // There should be exactly one method on this trait, and it should be the one we're diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs index c33a52f4a7a89..c9c1570a29a8b 100644 --- a/compiler/rustc_smir/src/rustc_internal/internal.rs +++ b/compiler/rustc_smir/src/rustc_internal/internal.rs @@ -408,7 +408,7 @@ impl RustcInternal for TraitRef { type T<'tcx> = rustc_ty::TraitRef<'tcx>; fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - rustc_ty::TraitRef::new( + rustc_ty::TraitRef::new_from_args( tcx, self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx), diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index b2fa3489dda2b..87d88312b4cfe 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -630,7 +630,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { let trait_pred_and_ty = trait_pred.map_bound(|inner| { ( ty::TraitPredicate { - trait_ref: ty::TraitRef::new( + trait_ref: ty::TraitRef::new_from_args( self.tcx, inner.trait_ref.def_id, self.tcx.mk_args( @@ -3955,7 +3955,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { // Extract `::Target` assoc type and check that it is `T` && let Some(deref_target_did) = tcx.lang_items().deref_target() - && let projection = Ty::new_projection(tcx,deref_target_did, tcx.mk_args(&[ty::GenericArg::from(found_ty)])) + && let projection = Ty::new_projection_from_args(tcx,deref_target_did, tcx.mk_args(&[ty::GenericArg::from(found_ty)])) && let InferOk { value: deref_target, obligations } = infcx.at(&ObligationCause::dummy(), param_env).normalize(projection) && obligations.iter().all(|obligation| infcx.predicate_must_hold_modulo_regions(obligation)) && infcx.can_eq(param_env, deref_target, target_ty) @@ -4290,7 +4290,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { // This corresponds to `::Item = _`. let projection = ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::Projection(ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(self.tcx, proj.def_id, args), + projection_term: ty::AliasTerm::new_from_args(self.tcx, proj.def_id, args), term: ty.into(), }), )); diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs index fc5a2875b67ad..4d10d33fa6ef5 100644 --- a/compiler/rustc_trait_selection/src/traits/object_safety.rs +++ b/compiler/rustc_trait_selection/src/traits/object_safety.rs @@ -689,7 +689,7 @@ fn receiver_is_dispatchable<'tcx>( if param.index == 0 { unsized_self_ty.into() } else { tcx.mk_param_from_def(param) } }); - ty::TraitRef::new(tcx, trait_def_id, args).upcast(tcx) + ty::TraitRef::new_from_args(tcx, trait_def_id, args).upcast(tcx) }; let caller_bounds = diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs index 8ab324e6601bc..1d7a05150444f 100644 --- a/compiler/rustc_trait_selection/src/traits/project.rs +++ b/compiler/rustc_trait_selection/src/traits/project.rs @@ -727,10 +727,12 @@ fn project<'cx, 'tcx>( ProjectionCandidateSet::None => { let tcx = selcx.tcx(); let term = match tcx.def_kind(obligation.predicate.def_id) { - DefKind::AssocTy => { - Ty::new_projection(tcx, obligation.predicate.def_id, obligation.predicate.args) - .into() - } + DefKind::AssocTy => Ty::new_projection_from_args( + tcx, + obligation.predicate.def_id, + obligation.predicate.args, + ) + .into(), DefKind::AssocConst => ty::Const::new_unevaluated( tcx, ty::UnevaluatedConst::new( @@ -1387,7 +1389,11 @@ fn confirm_coroutine_candidate<'cx, 'tcx>( }; let predicate = ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, obligation.predicate.def_id, trait_ref.args), + projection_term: ty::AliasTerm::new_from_args( + tcx, + obligation.predicate.def_id, + trait_ref.args, + ), term: ty.into(), }; @@ -1431,7 +1437,11 @@ fn confirm_future_candidate<'cx, 'tcx>( debug_assert_eq!(tcx.associated_item(obligation.predicate.def_id).name, sym::Output); let predicate = ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, obligation.predicate.def_id, trait_ref.args), + projection_term: ty::AliasTerm::new_from_args( + tcx, + obligation.predicate.def_id, + trait_ref.args, + ), term: return_ty.into(), }; @@ -1473,7 +1483,11 @@ fn confirm_iterator_candidate<'cx, 'tcx>( debug_assert_eq!(tcx.associated_item(obligation.predicate.def_id).name, sym::Item); let predicate = ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, obligation.predicate.def_id, trait_ref.args), + projection_term: ty::AliasTerm::new_from_args( + tcx, + obligation.predicate.def_id, + trait_ref.args, + ), term: yield_ty.into(), }; @@ -1523,7 +1537,11 @@ fn confirm_async_iterator_candidate<'cx, 'tcx>( let item_ty = args.type_at(0); let predicate = ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, obligation.predicate.def_id, trait_ref.args), + projection_term: ty::AliasTerm::new_from_args( + tcx, + obligation.predicate.def_id, + trait_ref.args, + ), term: item_ty.into(), }; @@ -1592,7 +1610,7 @@ fn confirm_builtin_candidate<'cx, 'tcx>( }; let predicate = ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, item_def_id, args), + projection_term: ty::AliasTerm::new_from_args(tcx, item_def_id, args), term, }; @@ -1753,7 +1771,7 @@ fn confirm_callable_candidate<'cx, 'tcx>( fn_host_effect, ) .map_bound(|(trait_ref, ret_type)| ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new(tcx, fn_once_output_def_id, trait_ref.args), + projection_term: ty::AliasTerm::new_from_args(tcx, fn_once_output_def_id, trait_ref.args), term: ret_type.into(), }); @@ -1937,7 +1955,7 @@ fn confirm_async_fn_kind_helper_candidate<'cx, 'tcx>( }; let predicate = ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new( + projection_term: ty::AliasTerm::new_from_args( selcx.tcx(), obligation.predicate.def_id, obligation.predicate.args, diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs index c53939bfe602f..e36a9ca8bd1c2 100644 --- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs +++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs @@ -940,7 +940,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let ty = traits::normalize_projection_ty( self, param_env, - ty::AliasTy::new(tcx, tcx.lang_items().deref_target()?, trait_ref.args), + ty::AliasTy::new_from_args(tcx, tcx.lang_items().deref_target()?, trait_ref.args), cause.clone(), 0, // We're *intentionally* throwing these away, diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs index fe047f9966f37..68cc04bc8e63d 100644 --- a/compiler/rustc_trait_selection/src/traits/select/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs @@ -2487,7 +2487,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> { trait_def_id, &[normalized_ty.into()], ); - ty::TraitRef::new(tcx, trait_def_id, err_args) + ty::TraitRef::new_from_args(tcx, trait_def_id, err_args) }; let obligation = Obligation::new(self.tcx(), cause.clone(), param_env, trait_ref); diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs index be6deee011b95..93ca7ab9280b9 100644 --- a/compiler/rustc_type_ir/src/inherent.rs +++ b/compiler/rustc_type_ir/src/inherent.rs @@ -47,6 +47,14 @@ pub trait Ty>: fn new_alias(interner: I, kind: ty::AliasTyKind, alias_ty: ty::AliasTy) -> Self; + fn new_projection_from_args(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self { + Ty::new_alias( + interner, + ty::AliasTyKind::Projection, + ty::AliasTy::new_from_args(interner, def_id, args), + ) + } + fn new_projection( interner: I, def_id: I::DefId, diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs index 59ca95c09cd78..69693043fa73d 100644 --- a/compiler/rustc_type_ir/src/interner.rs +++ b/compiler/rustc_type_ir/src/interner.rs @@ -169,11 +169,7 @@ pub trait Interner: fn check_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs) -> bool; - fn check_and_mk_args( - self, - def_id: Self::DefId, - args: impl IntoIterator>, - ) -> Self::GenericArgs; + fn debug_assert_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs); fn intern_canonical_goal_evaluation_step( self, diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs index 7a3376c7218da..392b758eea164 100644 --- a/compiler/rustc_type_ir/src/predicate.rs +++ b/compiler/rustc_type_ir/src/predicate.rs @@ -64,18 +64,23 @@ pub struct TraitRef { pub def_id: I::DefId, pub args: I::GenericArgs, /// This field exists to prevent the creation of `TraitRef` without - /// calling [`TraitRef::new`]. + /// calling [`TraitRef::new_from_args`]. _use_trait_ref_new_instead: (), } impl TraitRef { + pub fn new_from_args(interner: I, trait_def_id: I::DefId, args: I::GenericArgs) -> Self { + interner.debug_assert_args_compatible(trait_def_id, args); + Self { def_id: trait_def_id, args, _use_trait_ref_new_instead: () } + } + pub fn new( interner: I, trait_def_id: I::DefId, args: impl IntoIterator>, ) -> Self { - let args = interner.check_and_mk_args(trait_def_id, args); - Self { def_id: trait_def_id, args, _use_trait_ref_new_instead: () } + let args = interner.mk_args_from_iter(args.into_iter().map(Into::into)); + Self::new_from_args(interner, trait_def_id, args) } pub fn from_method(interner: I, trait_id: I::DefId, args: I::GenericArgs) -> TraitRef { @@ -86,7 +91,11 @@ impl TraitRef { /// Returns a `TraitRef` of the form `P0: Foo` where `Pi` /// are the parameters defined on trait. pub fn identity(interner: I, def_id: I::DefId) -> TraitRef { - TraitRef::new(interner, def_id, I::GenericArgs::identity_for_item(interner, def_id)) + TraitRef::new_from_args( + interner, + def_id, + I::GenericArgs::identity_for_item(interner, def_id), + ) } pub fn with_self_ty(self, interner: I, self_ty: I::Ty) -> Self { @@ -274,7 +283,7 @@ impl ty::Binder> { // If this is an ill-formed auto trait, then synthesize // new error args for the missing generics. let err_args = GenericArgs::extend_with_error(tcx, did, &[self_ty.into()]); - ty::TraitRef::new(tcx, did, err_args) + ty::TraitRef::new_from_args(tcx, did, err_args) }; self.rebind(trait_ref).upcast(tcx) } @@ -485,19 +494,24 @@ pub struct AliasTerm { /// aka. `interner.parent(def_id)`. pub def_id: I::DefId, - /// This field exists to prevent the creation of `AliasTerm` without using [`AliasTerm::new`]. + /// This field exists to prevent the creation of `AliasTerm` without using [`AliasTerm::new_from_args`]. #[derivative(Debug = "ignore")] _use_alias_term_new_instead: (), } impl AliasTerm { + pub fn new_from_args(interner: I, def_id: I::DefId, args: I::GenericArgs) -> AliasTerm { + interner.debug_assert_args_compatible(def_id, args); + AliasTerm { def_id, args, _use_alias_term_new_instead: () } + } + pub fn new( interner: I, def_id: I::DefId, args: impl IntoIterator>, ) -> AliasTerm { - let args = interner.check_and_mk_args(def_id, args); - AliasTerm { def_id, args, _use_alias_term_new_instead: () } + let args = interner.mk_args_from_iter(args.into_iter().map(Into::into)); + Self::new_from_args(interner, def_id, args) } pub fn expect_ty(self, interner: I) -> ty::AliasTy { diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs index 429bc3197d44d..350d8093b8646 100644 --- a/compiler/rustc_type_ir/src/relate.rs +++ b/compiler/rustc_type_ir/src/relate.rs @@ -258,7 +258,7 @@ impl Relate for ty::AliasTy { relate_args_invariantly(relation, a.args, b.args)? } }; - Ok(ty::AliasTy::new(relation.tcx(), a.def_id, args)) + Ok(ty::AliasTy::new_from_args(relation.tcx(), a.def_id, args)) } } } @@ -293,7 +293,7 @@ impl Relate for ty::AliasTerm { relate_args_invariantly(relation, a.args, b.args)? } }; - Ok(ty::AliasTerm::new(relation.tcx(), a.def_id, args)) + Ok(ty::AliasTerm::new_from_args(relation.tcx(), a.def_id, args)) } } } @@ -343,7 +343,7 @@ impl Relate for ty::TraitRef { })) } else { let args = relate_args_invariantly(relation, a.args, b.args)?; - Ok(ty::TraitRef::new(relation.tcx(), a.def_id, args)) + Ok(ty::TraitRef::new_from_args(relation.tcx(), a.def_id, args)) } } } diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs index 915888ab59b93..1c29fafc3ccac 100644 --- a/compiler/rustc_type_ir/src/ty_kind.rs +++ b/compiler/rustc_type_ir/src/ty_kind.rs @@ -352,7 +352,7 @@ impl fmt::Debug for TyKind { Float(float) => write!(f, "{float:?}"), Adt(d, s) => { write!(f, "{d:?}")?; - let mut s = s.into_iter(); + let mut s = s.iter(); let first = s.next(); match first { Some(first) => write!(f, "<{:?}", first)?, @@ -452,19 +452,24 @@ pub struct AliasTy { /// aka. `interner.parent(def_id)`. pub def_id: I::DefId, - /// This field exists to prevent the creation of `AliasTy` without using [`AliasTy::new`]. + /// This field exists to prevent the creation of `AliasTy` without using [`AliasTy::new_from_args`]. #[derivative(Debug = "ignore")] pub(crate) _use_alias_ty_new_instead: (), } impl AliasTy { + pub fn new_from_args(interner: I, def_id: I::DefId, args: I::GenericArgs) -> AliasTy { + interner.debug_assert_args_compatible(def_id, args); + AliasTy { def_id, args, _use_alias_ty_new_instead: () } + } + pub fn new( interner: I, def_id: I::DefId, args: impl IntoIterator>, ) -> AliasTy { - let args = interner.check_and_mk_args(def_id, args); - AliasTy { def_id, args, _use_alias_ty_new_instead: () } + let args = interner.mk_args_from_iter(args.into_iter().map(Into::into)); + Self::new_from_args(interner, def_id, args) } pub fn kind(self, interner: I) -> AliasTyKind { diff --git a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs index 58c1a2f270621..db5792188dd4b 100644 --- a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs +++ b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs @@ -61,7 +61,7 @@ fn is_impl_not_trait_with_bool_out<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) - ) }) .map_or(false, |assoc_item| { - let proj = Ty::new_projection(cx.tcx, assoc_item.def_id, cx.tcx.mk_args_trait(ty, [])); + let proj = Ty::new_projection_from_args(cx.tcx, assoc_item.def_id, cx.tcx.mk_args_trait(ty, [])); let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj); nty.is_bool() diff --git a/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs b/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs index f26f164fa54a4..46b457daf7074 100644 --- a/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs @@ -206,7 +206,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, sym::Item, [collect_ty]) && let Ok(into_iter_item_ty) = cx.tcx.try_normalize_erasing_regions( cx.param_env, - Ty::new_projection(cx.tcx, into_iter_item_proj.def_id, into_iter_item_proj.args), + Ty::new_projection_from_args(cx.tcx, into_iter_item_proj.def_id, into_iter_item_proj.args), ) { iter_item_ty == into_iter_item_ty @@ -235,7 +235,7 @@ fn is_contains_sig(cx: &LateContext<'_>, call_id: HirId, iter_expr: &Expr<'_>) - iter_trait, ) && let args = cx.tcx.mk_args(&[GenericArg::from(typeck.expr_ty_adjusted(iter_expr))]) - && let proj_ty = Ty::new_projection(cx.tcx, iter_item.def_id, args) + && let proj_ty = Ty::new_projection_from_args(cx.tcx, iter_item.def_id, args) && let Ok(item_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, proj_ty) { item_ty == EarlyBinder::bind(search_ty).instantiate(cx.tcx, cx.typeck_results().node_args(call_id)) diff --git a/src/tools/clippy/clippy_lints/src/redundant_slicing.rs b/src/tools/clippy/clippy_lints/src/redundant_slicing.rs index 7f87d18e50238..82f22ad693d78 100644 --- a/src/tools/clippy/clippy_lints/src/redundant_slicing.rs +++ b/src/tools/clippy/clippy_lints/src/redundant_slicing.rs @@ -133,7 +133,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing { } else if let Some(target_id) = cx.tcx.lang_items().deref_target() { if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions( cx.param_env, - Ty::new_projection(cx.tcx, target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])), + Ty::new_projection_from_args(cx.tcx, target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])), ) { if deref_ty == expr_ty { let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0; diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs index 7d4332a3d9de8..3790a852f7edb 100644 --- a/src/tools/clippy/clippy_utils/src/ty.rs +++ b/src/tools/clippy/clippy_utils/src/ty.rs @@ -292,7 +292,7 @@ pub fn implements_trait_with_env_from_iter<'tcx>( let trait_ref = TraitRef::new( tcx, trait_id, - Some(GenericArg::from(ty)).into_iter().chain(args).chain(effect_arg), + [GenericArg::from(ty)].into_iter().chain(args).chain(effect_arg), ); debug_assert_matches!( @@ -1126,7 +1126,7 @@ pub fn make_projection<'tcx>( #[cfg(debug_assertions)] assert_generic_args_match(tcx, assoc_item.def_id, args); - Some(AliasTy::new(tcx, assoc_item.def_id, args)) + Some(AliasTy::new_from_args(tcx, assoc_item.def_id, args)) } helper( tcx, @@ -1165,7 +1165,7 @@ pub fn make_normalized_projection<'tcx>( ); return None; } - match tcx.try_normalize_erasing_regions(param_env, Ty::new_projection(tcx, ty.def_id, ty.args)) { + match tcx.try_normalize_erasing_regions(param_env, Ty::new_projection_from_args(tcx, ty.def_id, ty.args)) { Ok(ty) => Some(ty), Err(e) => { debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}"); @@ -1289,7 +1289,7 @@ pub fn make_normalized_projection_with_regions<'tcx>( .infer_ctxt() .build() .at(&cause, param_env) - .query_normalize(Ty::new_projection(tcx, ty.def_id, ty.args)) + .query_normalize(Ty::new_projection_from_args(tcx, ty.def_id, ty.args)) { Ok(ty) => Some(ty.value), Err(e) => { From 24e41f1d134fdd969308894baddced76ad79712d Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Fri, 21 Jun 2024 13:55:21 -0400 Subject: [PATCH 2/3] Replace Deref bounds on Interner in favor of a SliceLike trait --- compiler/rustc_middle/src/ty/list.rs | 14 +++ .../src/solve/assembly/mod.rs | 4 +- .../src/solve/assembly/structural_traits.rs | 33 +++--- .../src/solve/eval_ctxt/canonical.rs | 11 +- .../src/solve/eval_ctxt/mod.rs | 4 +- .../src/solve/inspect/build.rs | 1 + .../rustc_next_trait_solver/src/solve/mod.rs | 2 +- .../src/solve/normalizes_to/inherent.rs | 6 +- .../src/solve/normalizes_to/mod.rs | 20 ++-- .../src/solve/normalizes_to/opaque_types.rs | 4 +- .../src/solve/normalizes_to/weak_types.rs | 4 +- .../src/solve/trait_goals.rs | 27 ++--- compiler/rustc_type_ir/src/binder.rs | 35 +++--- compiler/rustc_type_ir/src/canonical.rs | 12 +- compiler/rustc_type_ir/src/inherent.rs | 107 ++++++++++++++---- compiler/rustc_type_ir/src/interner.rs | 20 +--- compiler/rustc_type_ir/src/opaque_ty.rs | 10 +- compiler/rustc_type_ir/src/predicate.rs | 20 ++-- compiler/rustc_type_ir/src/relate.rs | 22 ++-- compiler/rustc_type_ir/src/ty_kind.rs | 6 +- compiler/rustc_type_ir/src/ty_kind/closure.rs | 16 +-- .../src/needless_borrows_for_generic_args.rs | 2 +- 22 files changed, 221 insertions(+), 159 deletions(-) diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs index 71a93cc520d5b..73eba93194e1e 100644 --- a/compiler/rustc_middle/src/ty/list.rs +++ b/compiler/rustc_middle/src/ty/list.rs @@ -133,6 +133,20 @@ impl RawList { } } +impl<'a, H, T: Copy> rustc_type_ir::inherent::SliceLike for &'a RawList { + type Item = T; + + type IntoIter = iter::Copied<<&'a [T] as IntoIterator>::IntoIter>; + + fn iter(self) -> Self::IntoIter { + (*self).iter() + } + + fn as_slice(&self) -> &[Self::Item] { + (*self).as_slice() + } +} + macro_rules! impl_list_empty { ($header_ty:ty, $header_init:expr) => { impl RawList<$header_ty, T> { 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 cae9c5c85678e..ee7279a43b2cf 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs @@ -527,7 +527,7 @@ where }; for assumption in - self.cx().item_bounds(alias_ty.def_id).iter_instantiated(self.cx(), &alias_ty.args) + self.cx().item_bounds(alias_ty.def_id).iter_instantiated(self.cx(), alias_ty.args) { candidates.extend(G::probe_and_consider_implied_clause( self, @@ -603,7 +603,7 @@ where // Consider all of the auto-trait and projection bounds, which don't // need to be recorded as a `BuiltinImplSource::Object` since they don't // really have a vtable base... - for bound in bounds { + for bound in bounds.iter() { match bound.skip_binder() { ty::ExistentialPredicate::Trait(_) => { // Skip principal 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 b10be5a9ba700..d4890e48032f0 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 @@ -58,7 +58,7 @@ where ty::Tuple(tys) => { // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet - Ok(tys.into_iter().map(ty::Binder::dummy).collect()) + Ok(tys.iter().map(ty::Binder::dummy).collect()) } ty::Closure(_, args) => Ok(vec![ty::Binder::dummy(args.as_closure().tupled_upvars_ty())]), @@ -79,23 +79,21 @@ where .cx() .bound_coroutine_hidden_types(def_id) .into_iter() - .map(|bty| bty.instantiate(tcx, &args)) + .map(|bty| bty.instantiate(tcx, args)) .collect()), // For `PhantomData`, we pass `T`. ty::Adt(def, args) if def.is_phantom_data() => Ok(vec![ty::Binder::dummy(args.type_at(0))]), - ty::Adt(def, args) => Ok(def - .all_field_tys(tcx) - .iter_instantiated(tcx, &args) - .map(ty::Binder::dummy) - .collect()), + ty::Adt(def, args) => { + Ok(def.all_field_tys(tcx).iter_instantiated(tcx, args).map(ty::Binder::dummy).collect()) + } ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => { // We can resolve the `impl Trait` to its concrete type, // which enforces a DAG between the functions requiring // the auto trait bounds in question. - Ok(vec![ty::Binder::dummy(tcx.type_of(def_id).instantiate(tcx, &args))]) + Ok(vec![ty::Binder::dummy(tcx.type_of(def_id).instantiate(tcx, args))]) } } } @@ -147,7 +145,7 @@ where // impl Sized for () // impl Sized for (T1, T2, .., Tn) where Tn: Sized if n >= 1 - ty::Tuple(tys) => Ok(tys.last().map_or_else(Vec::new, |&ty| vec![ty::Binder::dummy(ty)])), + ty::Tuple(tys) => Ok(tys.last().map_or_else(Vec::new, |ty| vec![ty::Binder::dummy(ty)])), // impl Sized for Adt where sized_constraint(Adt): Sized // `sized_constraint(Adt)` is the deepest struct trail that can be determined @@ -160,7 +158,7 @@ where // if the ADT is sized for all possible args. ty::Adt(def, args) => { if let Some(sized_crit) = def.sized_constraint(ecx.cx()) { - Ok(vec![ty::Binder::dummy(sized_crit.instantiate(ecx.cx(), &args))]) + Ok(vec![ty::Binder::dummy(sized_crit.instantiate(ecx.cx(), args))]) } else { Ok(vec![]) } @@ -213,7 +211,7 @@ where } // impl Copy/Clone for (T1, T2, .., Tn) where T1: Copy/Clone, T2: Copy/Clone, .. Tn: Copy/Clone - ty::Tuple(tys) => Ok(tys.into_iter().map(ty::Binder::dummy).collect()), + ty::Tuple(tys) => Ok(tys.iter().map(ty::Binder::dummy).collect()), // impl Copy/Clone for Closure where Self::TupledUpvars: Copy/Clone ty::Closure(_, args) => Ok(vec![ty::Binder::dummy(args.as_closure().tupled_upvars_ty())]), @@ -242,7 +240,7 @@ where .cx() .bound_coroutine_hidden_types(def_id) .into_iter() - .map(|bty| bty.instantiate(ecx.cx(), &args)) + .map(|bty| bty.instantiate(ecx.cx(), args)) .collect()), } } @@ -259,7 +257,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable { if let ty::Bound(debruijn, b) = t.kind() { @@ -291,7 +293,7 @@ where } let var_values = delegate.cx().mk_args_from_iter( - response.variables.into_iter().enumerate().map(|(index, info)| { + response.variables.iter().enumerate().map(|(index, info)| { if info.universe() != ty::UniverseIndex::ROOT { // A variable from inside a binder of the query. While ideally these shouldn't // exist at all (see the FIXME at the start of this method), we have to deal with @@ -344,7 +346,7 @@ where ) { assert_eq!(original_values.len(), var_values.len()); - for (&orig, response) in iter::zip(original_values, var_values.var_values) { + for (&orig, response) in iter::zip(original_values, var_values.var_values.iter()) { let goals = delegate.eq_structurally_relating_aliases(param_env, orig, response).unwrap(); assert!(goals.is_empty()); @@ -413,7 +415,8 @@ where // In case any fresh inference variables have been created between `state` // and the previous instantiation, extend `orig_values` for it. assert!(orig_values.len() <= state.value.var_values.len()); - for &arg in &state.value.var_values.var_values[orig_values.len()..state.value.var_values.len()] + for &arg in &state.value.var_values.var_values.as_slice() + [orig_values.len()..state.value.var_values.len()] { // FIXME: This is so ugly. let unconstrained = delegate.fresh_var_for_kind_with_span(arg, span); diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs index 687623d440845..04dce2780b07b 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs @@ -875,7 +875,7 @@ where pub(super) fn fresh_args_for_item(&mut self, def_id: I::DefId) -> I::GenericArgs { let args = self.delegate.fresh_args_for_item(def_id); - for arg in args { + for arg in args.iter() { self.inspect.add_var_value(arg); } args @@ -979,7 +979,7 @@ where result: *result, }) .enter(|ecx| { - for (a, b) in std::iter::zip(candidate_key.args, key.args) { + for (a, b) in std::iter::zip(candidate_key.args.iter(), key.args.iter()) { ecx.eq(param_env, a, b)?; } ecx.eq(param_env, candidate_ty, ty)?; diff --git a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs index ae59f0c5e9572..4fc58e06d67dc 100644 --- a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs +++ b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs @@ -7,6 +7,7 @@ use std::marker::PhantomData; use std::mem; +use rustc_type_ir::inherent::*; use rustc_type_ir::{self as ty, Interner}; use crate::delegate::SolverDelegate; diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs index b76b4c098523e..e29ae7ac0a26c 100644 --- a/compiler/rustc_next_trait_solver/src/solve/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs @@ -182,7 +182,7 @@ where return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes); } ty::ConstKind::Unevaluated(uv) => { - self.cx().type_of(uv.def).instantiate(self.cx(), &uv.args) + self.cx().type_of(uv.def).instantiate(self.cx(), uv.args) } ty::ConstKind::Expr(_) => unimplemented!( "`feature(generic_const_exprs)` is not supported in the new trait solver" diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs index 827fe5f2ca405..004ecf2d2c4f7 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs @@ -29,7 +29,7 @@ where self.eq( goal.param_env, inherent.self_ty(), - tcx.type_of(impl_def_id).instantiate(tcx, &impl_args), + tcx.type_of(impl_def_id).instantiate(tcx, impl_args), )?; // Equate IAT with the RHS of the project goal @@ -44,11 +44,11 @@ where self.add_goals( GoalSource::Misc, tcx.predicates_of(inherent.def_id) - .iter_instantiated(tcx, &inherent_args) + .iter_instantiated(tcx, inherent_args) .map(|pred| goal.with(tcx, pred)), ); - let normalized = tcx.type_of(inherent.def_id).instantiate(tcx, &inherent_args); + let normalized = tcx.type_of(inherent.def_id).instantiate(tcx, inherent_args); self.instantiate_normalizes_to_term(goal, normalized.into()); self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) } 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 f58384d86cd68..bc5233c4887fa 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 @@ -121,7 +121,7 @@ where ecx.add_goals( GoalSource::Misc, tcx.own_predicates_of(goal.predicate.def_id()) - .iter_instantiated(tcx, &goal.predicate.alias.args) + .iter_instantiated(tcx, goal.predicate.alias.args) .map(|pred| goal.with(tcx, pred)), ); @@ -163,13 +163,13 @@ where ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| { let impl_args = ecx.fresh_args_for_item(impl_def_id); - let impl_trait_ref = impl_trait_ref.instantiate(tcx, &impl_args); + let impl_trait_ref = impl_trait_ref.instantiate(tcx, impl_args); ecx.eq(goal.param_env, goal_trait_ref, impl_trait_ref)?; let where_clause_bounds = tcx .predicates_of(impl_def_id) - .iter_instantiated(tcx, &impl_args) + .iter_instantiated(tcx, impl_args) .map(|pred| goal.with(tcx, pred)); ecx.add_goals(GoalSource::ImplWhereBound, where_clause_bounds); @@ -177,7 +177,7 @@ where ecx.add_goals( GoalSource::Misc, tcx.own_predicates_of(goal.predicate.def_id()) - .iter_instantiated(tcx, &goal.predicate.alias.args) + .iter_instantiated(tcx, goal.predicate.alias.args) .map(|pred| goal.with(tcx, pred)), ); @@ -254,7 +254,7 @@ where kind => panic!("expected projection, found {kind:?}"), }; - ecx.instantiate_normalizes_to_term(goal, term.instantiate(tcx, &target_args)); + ecx.instantiate_normalizes_to_term(goal, term.instantiate(tcx, target_args)); ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) }) } @@ -467,7 +467,7 @@ where tupled_inputs_ty, tupled_upvars_ty, coroutine_captures_by_ref_ty, - ] = **goal.predicate.alias.args + ] = *goal.predicate.alias.args.as_slice() else { panic!(); }; @@ -567,14 +567,14 @@ where ty::Adt(def, args) if def.is_struct() => match def.struct_tail_ty(tcx) { None => Ty::new_unit(tcx), Some(tail_ty) => { - Ty::new_projection(tcx, metadata_def_id, [tail_ty.instantiate(tcx, &args)]) + Ty::new_projection(tcx, metadata_def_id, [tail_ty.instantiate(tcx, args)]) } }, ty::Adt(_, _) => Ty::new_unit(tcx), ty::Tuple(elements) => match elements.last() { None => Ty::new_unit(tcx), - Some(&tail_ty) => Ty::new_projection(tcx, metadata_def_id, [tail_ty]), + Some(tail_ty) => Ty::new_projection(tcx, metadata_def_id, [tail_ty]), }, ty::Infer( @@ -895,7 +895,7 @@ where } else { let target_args = self.fresh_args_for_item(target_container_def_id); let target_trait_ref = - tcx.impl_trait_ref(target_container_def_id).instantiate(tcx, &target_args); + tcx.impl_trait_ref(target_container_def_id).instantiate(tcx, target_args); // Relate source impl to target impl by equating trait refs. self.eq(goal.param_env, impl_trait_ref, target_trait_ref)?; // Also add predicates since they may be needed to constrain the @@ -903,7 +903,7 @@ where self.add_goals( GoalSource::Misc, tcx.predicates_of(target_container_def_id) - .iter_instantiated(tcx, &target_args) + .iter_instantiated(tcx, target_args) .map(|pred| goal.with(tcx, pred)), ); goal.predicate.alias.args.rebase_onto(tcx, impl_trait_ref.def_id, target_args) diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs index f3494328d9e48..a16f9e64f2f74 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs @@ -86,7 +86,7 @@ where } (Reveal::All, _) => { // FIXME: Add an assertion that opaque type storage is empty. - let actual = tcx.type_of(opaque_ty.def_id).instantiate(tcx, &opaque_ty.args); + let actual = tcx.type_of(opaque_ty.def_id).instantiate(tcx, opaque_ty.args); self.eq(goal.param_env, expected, actual)?; self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) } @@ -102,7 +102,7 @@ pub fn uses_unique_placeholders_ignoring_regions( args: I::GenericArgs, ) -> Result<(), NotUniqueParam> { let mut seen = GrowableBitSet::default(); - for arg in args { + for arg in args.iter() { match arg.kind() { // Ignore regions, since we can't resolve those in a canonicalized // query in the trait solver. diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs index 27d5ae07729a6..ca90bc17cc7d8 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs @@ -25,11 +25,11 @@ where self.add_goals( GoalSource::Misc, tcx.predicates_of(weak_ty.def_id) - .iter_instantiated(tcx, &weak_ty.args) + .iter_instantiated(tcx, weak_ty.args) .map(|pred| goal.with(tcx, pred)), ); - let actual = tcx.type_of(weak_ty.def_id).instantiate(tcx, &weak_ty.args); + let actual = tcx.type_of(weak_ty.def_id).instantiate(tcx, weak_ty.args); self.instantiate_normalizes_to_term(goal, actual.into()); self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) 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 2ddb3c981db94..9746c836aff55 100644 --- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs @@ -77,12 +77,12 @@ where ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| { let impl_args = ecx.fresh_args_for_item(impl_def_id); ecx.record_impl_args(impl_args); - let impl_trait_ref = impl_trait_ref.instantiate(tcx, &impl_args); + let impl_trait_ref = impl_trait_ref.instantiate(tcx, impl_args); ecx.eq(goal.param_env, goal.predicate.trait_ref, impl_trait_ref)?; let where_clause_bounds = tcx .predicates_of(impl_def_id) - .iter_instantiated(tcx, &impl_args) + .iter_instantiated(tcx, impl_args) .map(|pred| goal.with(tcx, pred)); ecx.add_goals(GoalSource::ImplWhereBound, where_clause_bounds); @@ -186,7 +186,7 @@ where ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { let nested_obligations = tcx .predicates_of(goal.predicate.def_id()) - .iter_instantiated(tcx, &goal.predicate.trait_ref.args) + .iter_instantiated(tcx, goal.predicate.trait_ref.args) .map(|p| goal.with(tcx, p)); // FIXME(-Znext-solver=coinductive): Should this be `GoalSource::ImplWhereBound`? ecx.add_goals(GoalSource::Misc, nested_obligations); @@ -373,7 +373,7 @@ where ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { - let [closure_fn_kind_ty, goal_kind_ty] = **goal.predicate.trait_ref.args else { + let [closure_fn_kind_ty, goal_kind_ty] = *goal.predicate.trait_ref.args.as_slice() else { panic!(); }; @@ -783,7 +783,7 @@ where // (i.e. the principal, all of the associated types match, and any auto traits) ecx.add_goals( GoalSource::ImplWhereBound, - b_data.into_iter().map(|pred| goal.with(tcx, pred.with_self_ty(tcx, a_ty))), + b_data.iter().map(|pred| goal.with(tcx, pred.with_self_ty(tcx, a_ty))), ); // The type must be `Sized` to be unsized. @@ -851,7 +851,7 @@ where }; self.probe_trait_candidate(source).enter(|ecx| { - for bound in b_data { + for bound in b_data.iter() { match bound.skip_binder() { // Check that a's supertrait (upcast_principal) is compatible // with the target (b_ty). @@ -953,18 +953,15 @@ where let tail_field_ty = def.struct_tail_ty(tcx).unwrap(); - let a_tail_ty = tail_field_ty.instantiate(tcx, &a_args); - let b_tail_ty = tail_field_ty.instantiate(tcx, &b_args); + let a_tail_ty = tail_field_ty.instantiate(tcx, a_args); + let b_tail_ty = tail_field_ty.instantiate(tcx, b_args); // Instantiate just the unsizing params from B into A. The type after // this instantiation must be equal to B. This is so we don't unsize // unrelated type parameters. - let new_a_args = tcx.mk_args_from_iter( - a_args - .iter() - .enumerate() - .map(|(i, a)| if unsizing_params.contains(i as u32) { b_args[i] } else { *a }), - ); + let new_a_args = tcx.mk_args_from_iter(a_args.iter().enumerate().map(|(i, a)| { + if unsizing_params.contains(i as u32) { b_args.get(i).unwrap() } else { a } + })); let unsized_a_ty = Ty::new_adt(tcx, def, new_a_args); // Finally, we require that `TailA: Unsize` for the tail field @@ -1005,7 +1002,7 @@ where let Goal { predicate: (_a_ty, b_ty), .. } = goal; let (&a_last_ty, a_rest_tys) = a_tys.split_last().unwrap(); - let &b_last_ty = b_tys.last().unwrap(); + let b_last_ty = b_tys.last().unwrap(); // Instantiate just the tail field of B., and require that they're equal. let unsized_a_ty = diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs index 18b34f8d99b94..491ef34430c15 100644 --- a/compiler/rustc_type_ir/src/binder.rs +++ b/compiler/rustc_type_ir/src/binder.rs @@ -320,7 +320,7 @@ impl TypeVisitor for ValidateBoundVars { if self.bound_vars.len() <= idx { panic!("Not enough bound vars: {:?} not found in {:?}", t, self.bound_vars); } - bound_ty.assert_eq(self.bound_vars[idx]); + bound_ty.assert_eq(self.bound_vars.get(idx).unwrap()); } _ => {} }; @@ -335,7 +335,7 @@ impl TypeVisitor for ValidateBoundVars { if self.bound_vars.len() <= idx { panic!("Not enough bound vars: {:?} not found in {:?}", r, self.bound_vars); } - br.assert_eq(self.bound_vars[idx]); + br.assert_eq(self.bound_vars.get(idx).unwrap()); } _ => (), @@ -435,15 +435,14 @@ impl EarlyBinder> { } } -impl<'s, I: Interner, Iter: IntoIterator> EarlyBinder +impl EarlyBinder where Iter::Item: TypeFoldable, { - pub fn iter_instantiated( - self, - tcx: I, - args: &'s [I::GenericArg], - ) -> IterInstantiated<'s, I, Iter> { + pub fn iter_instantiated(self, tcx: I, args: A) -> IterInstantiated + where + A: SliceLike, + { IterInstantiated { it: self.value.into_iter(), tcx, args } } @@ -454,15 +453,16 @@ where } } -pub struct IterInstantiated<'s, I: Interner, Iter: IntoIterator> { +pub struct IterInstantiated { it: Iter::IntoIter, tcx: I, - args: &'s [I::GenericArg], + args: A, } -impl Iterator for IterInstantiated<'_, I, Iter> +impl Iterator for IterInstantiated where Iter::Item: TypeFoldable, + A: SliceLike, { type Item = Iter::Item; @@ -478,10 +478,11 @@ where } } -impl DoubleEndedIterator for IterInstantiated<'_, I, Iter> +impl DoubleEndedIterator for IterInstantiated where Iter::IntoIter: DoubleEndedIterator, Iter::Item: TypeFoldable, + A: SliceLike, { fn next_back(&mut self) -> Option { Some( @@ -491,10 +492,11 @@ where } } -impl ExactSizeIterator for IterInstantiated<'_, I, Iter> +impl ExactSizeIterator for IterInstantiated where Iter::IntoIter: ExactSizeIterator, Iter::Item: TypeFoldable, + A: SliceLike, { } @@ -589,8 +591,11 @@ impl Iterator for EarlyBinderIter { } impl> ty::EarlyBinder { - pub fn instantiate(self, tcx: I, args: &[I::GenericArg]) -> T { - let mut folder = ArgFolder { tcx, args, binders_passed: 0 }; + pub fn instantiate(self, tcx: I, args: A) -> T + where + A: SliceLike, + { + let mut folder = ArgFolder { tcx, args: args.as_slice(), binders_passed: 0 }; self.value.fold_with(&mut folder) } diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs index 61ae36265ec7c..7b114f565f29e 100644 --- a/compiler/rustc_type_ir/src/canonical.rs +++ b/compiler/rustc_type_ir/src/canonical.rs @@ -283,7 +283,7 @@ pub struct CanonicalVarValues { impl CanonicalVarValues { pub fn is_identity(&self) -> bool { - self.var_values.into_iter().enumerate().all(|(bv, arg)| match arg.kind() { + self.var_values.iter().enumerate().all(|(bv, arg)| match arg.kind() { ty::GenericArgKind::Lifetime(r) => { matches!(r.kind(), ty::ReBound(ty::INNERMOST, br) if br.var().as_usize() == bv) } @@ -298,7 +298,7 @@ impl CanonicalVarValues { pub fn is_identity_modulo_regions(&self) -> bool { let mut var = ty::BoundVar::ZERO; - for arg in self.var_values { + for arg in self.var_values.iter() { match arg.kind() { ty::GenericArgKind::Lifetime(r) => { if matches!(r.kind(), ty::ReBound(ty::INNERMOST, br) if var == br.var()) { @@ -332,7 +332,7 @@ impl CanonicalVarValues { // the identity response. pub fn make_identity(tcx: I, infos: I::CanonicalVars) -> CanonicalVarValues { CanonicalVarValues { - var_values: tcx.mk_args_from_iter(infos.into_iter().enumerate().map( + var_values: tcx.mk_args_from_iter(infos.iter().enumerate().map( |(i, info)| -> I::GenericArg { match info.kind { CanonicalVarKind::Ty(_) | CanonicalVarKind::PlaceholderTy(_) => { @@ -371,10 +371,10 @@ impl CanonicalVarValues { impl<'a, I: Interner> IntoIterator for &'a CanonicalVarValues { type Item = I::GenericArg; - type IntoIter = ::IntoIter; + type IntoIter = ::IntoIter; fn into_iter(self) -> Self::IntoIter { - self.var_values.into_iter() + self.var_values.iter() } } @@ -382,6 +382,6 @@ impl Index for CanonicalVarValues { type Output = I::GenericArg; fn index(&self, value: ty::BoundVar) -> &I::GenericArg { - &self.var_values[value.as_usize()] + &self.var_values.as_slice()[value.as_usize()] } } diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs index 93ca7ab9280b9..a4e1a97d50587 100644 --- a/compiler/rustc_type_ir/src/inherent.rs +++ b/compiler/rustc_type_ir/src/inherent.rs @@ -5,7 +5,6 @@ use std::fmt::Debug; use std::hash::Hash; -use std::ops::Deref; use rustc_ast_ir::Mutability; @@ -128,7 +127,7 @@ pub trait Ty>: fn fn_sig(self, interner: I) -> ty::Binder> { match self.kind() { ty::FnPtr(sig) => sig, - ty::FnDef(def_id, args) => interner.fn_sig(def_id).instantiate(interner, &args), + ty::FnDef(def_id, args) => interner.fn_sig(def_id).instantiate(interner, args), ty::Error(_) => { // ignore errors (#54954) ty::Binder::dummy(ty::FnSig { @@ -190,14 +189,7 @@ pub trait Ty>: } pub trait Tys>: - Copy - + Debug - + Hash - + Eq - + IntoIterator - + Deref> - + TypeFoldable - + Default + Copy + Debug + Hash + Eq + SliceLike + TypeFoldable + Default { fn split_inputs_and_output(self) -> (I::FnInputTys, I::Ty); } @@ -362,14 +354,7 @@ pub trait Term>: } pub trait GenericArgs>: - Copy - + Debug - + Hash - + Eq - + IntoIterator - + Deref> - + Default - + Relate + Copy + Debug + Hash + Eq + SliceLike + Default + Relate { fn rebase_onto( self, @@ -561,12 +546,7 @@ pub trait DefId: Copy + Debug + Hash + Eq + TypeFoldable { } pub trait BoundExistentialPredicates: - Copy - + Debug - + Hash - + Eq - + Relate - + IntoIterator>> + Copy + Debug + Hash + Eq + Relate + SliceLike>> { fn principal_def_id(self) -> Option; @@ -578,3 +558,82 @@ pub trait BoundExistentialPredicates: self, ) -> impl IntoIterator>>; } + +pub trait SliceLike: Sized + Copy { + type Item: Copy; + type IntoIter: Iterator; + + fn iter(self) -> Self::IntoIter; + + fn as_slice(&self) -> &[Self::Item]; + + fn get(self, idx: usize) -> Option { + self.as_slice().get(idx).copied() + } + + fn len(self) -> usize { + self.as_slice().len() + } + + fn is_empty(self) -> bool { + self.len() == 0 + } + + fn contains(self, t: &Self::Item) -> bool + where + Self::Item: PartialEq, + { + self.as_slice().contains(t) + } + + fn to_vec(self) -> Vec { + self.as_slice().to_vec() + } + + fn last(self) -> Option { + self.as_slice().last().copied() + } + + fn split_last(&self) -> Option<(&Self::Item, &[Self::Item])> { + self.as_slice().split_last() + } +} + +impl<'a, T: Copy> SliceLike for &'a [T] { + type Item = T; + type IntoIter = std::iter::Copied>; + + fn iter(self) -> Self::IntoIter { + self.iter().copied() + } + + fn as_slice(&self) -> &[Self::Item] { + *self + } +} + +impl<'a, T: Copy, const N: usize> SliceLike for &'a [T; N] { + type Item = T; + type IntoIter = std::iter::Copied>; + + fn iter(self) -> Self::IntoIter { + self.into_iter().copied() + } + + fn as_slice(&self) -> &[Self::Item] { + *self + } +} + +impl<'a, S: SliceLike> SliceLike for &'a S { + type Item = S::Item; + type IntoIter = S::IntoIter; + + fn iter(self) -> Self::IntoIter { + (*self).iter() + } + + fn as_slice(&self) -> &[Self::Item] { + (*self).as_slice() + } +} diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs index 69693043fa73d..3640a8dea5444 100644 --- a/compiler/rustc_type_ir/src/interner.rs +++ b/compiler/rustc_type_ir/src/interner.rs @@ -34,16 +34,11 @@ pub trait Interner: type LocalDefId: Copy + Debug + Hash + Eq + Into + TypeFoldable; type GenericArgs: GenericArgs; - type GenericArgsSlice: Copy + Debug + Hash + Eq + Deref; + type GenericArgsSlice: Copy + Debug + Hash + Eq + SliceLike; type GenericArg: GenericArg; type Term: Term; - type BoundVarKinds: Copy - + Debug - + Hash - + Eq - + Deref> - + Default; + type BoundVarKinds: Copy + Debug + Hash + Eq + SliceLike + Default; type BoundVarKind: Copy + Debug + Hash + Eq; type PredefinedOpaques: Copy @@ -63,7 +58,7 @@ pub trait Interner: + Default + Eq + TypeVisitable - + Deref>; + + SliceLike; type CanonicalGoalEvaluationStepRef: Copy + Debug + Hash @@ -74,8 +69,7 @@ pub trait Interner: + Debug + Hash + Eq - + IntoIterator> - + Deref]>> + + SliceLike> + Default; fn mk_canonical_var_infos(self, infos: &[ty::CanonicalVarInfo]) -> Self::CanonicalVars; @@ -138,11 +132,7 @@ pub trait Interner: type GenericsOf: GenericsOf; fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf; - type VariancesOf: Copy - + Debug - + Deref - // FIXME: This is terrible! - + IntoIterator>; + type VariancesOf: Copy + Debug + SliceLike; fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf; fn type_of(self, def_id: Self::DefId) -> ty::EarlyBinder; diff --git a/compiler/rustc_type_ir/src/opaque_ty.rs b/compiler/rustc_type_ir/src/opaque_ty.rs index 738350f1b34f2..d8ed4770e2dc1 100644 --- a/compiler/rustc_type_ir/src/opaque_ty.rs +++ b/compiler/rustc_type_ir/src/opaque_ty.rs @@ -24,13 +24,13 @@ pub struct OpaqueTypeKey { impl OpaqueTypeKey { pub fn iter_captured_args(self, tcx: I) -> impl Iterator { let variances = tcx.variances_of(self.def_id.into()); - std::iter::zip(self.args, variances.into_iter()).enumerate().filter_map(|(i, (arg, v))| { - match (arg.kind(), *v) { + std::iter::zip(self.args.iter(), variances.iter()).enumerate().filter_map( + |(i, (arg, v))| match (arg.kind(), v) { (_, ty::Invariant) => Some((i, arg)), (ty::GenericArgKind::Lifetime(_), ty::Bivariant) => None, _ => panic!("unexpected opaque type arg variance"), - } - }) + }, + ) } pub fn fold_captured_lifetime_args( @@ -41,7 +41,7 @@ impl OpaqueTypeKey { let Self { def_id, args } = self; let variances = tcx.variances_of(def_id.into()); let args = - std::iter::zip(args, variances.into_iter()).map(|(arg, v)| match (arg.kind(), *v) { + std::iter::zip(args.iter(), variances.iter()).map(|(arg, v)| match (arg.kind(), v) { (ty::GenericArgKind::Lifetime(_), ty::Bivariant) => arg, (ty::GenericArgKind::Lifetime(lt), _) => f(lt).into(), _ => arg, diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs index 392b758eea164..e5bcbc67f946c 100644 --- a/compiler/rustc_type_ir/src/predicate.rs +++ b/compiler/rustc_type_ir/src/predicate.rs @@ -85,7 +85,7 @@ impl TraitRef { pub fn from_method(interner: I, trait_id: I::DefId, args: I::GenericArgs) -> TraitRef { let generics = interner.generics_of(trait_id); - TraitRef::new(interner, trait_id, args.into_iter().take(generics.count())) + TraitRef::new(interner, trait_id, args.iter().take(generics.count())) } /// Returns a `TraitRef` of the form `P0: Foo` where `Pi` @@ -102,7 +102,7 @@ impl TraitRef { TraitRef::new( interner, self.def_id, - [self_ty.into()].into_iter().chain(self.args.into_iter().skip(1)), + [self_ty.into()].into_iter().chain(self.args.iter().skip(1)), ) } @@ -320,7 +320,7 @@ impl ExistentialTraitRef { ExistentialTraitRef { def_id: trait_ref.def_id, - args: interner.mk_args(&trait_ref.args[1..]), + args: interner.mk_args(&trait_ref.args.as_slice()[1..]), } } @@ -332,11 +332,7 @@ impl ExistentialTraitRef { // otherwise the escaping vars would be captured by the binder // debug_assert!(!self_ty.has_escaping_bound_vars()); - TraitRef::new( - interner, - self.def_id, - [self_ty.into()].into_iter().chain(self.args.into_iter()), - ) + TraitRef::new(interner, self.def_id, [self_ty.into()].into_iter().chain(self.args.iter())) } } @@ -379,7 +375,7 @@ impl ExistentialProjection { pub fn trait_ref(&self, interner: I) -> ExistentialTraitRef { let def_id = interner.parent(self.def_id); let args_count = interner.generics_of(def_id).count() - 1; - let args = interner.mk_args(&self.args[..args_count]); + let args = interner.mk_args(&self.args.as_slice()[..args_count]); ExistentialTraitRef { def_id, args } } @@ -391,7 +387,7 @@ impl ExistentialProjection { projection_term: AliasTerm::new( interner, self.def_id, - [self_ty.into()].into_iter().chain(self.args), + [self_ty.into()].iter().chain(self.args.iter()), ), term: self.term, } @@ -403,7 +399,7 @@ impl ExistentialProjection { Self { def_id: projection_predicate.projection_term.def_id, - args: interner.mk_args(&projection_predicate.projection_term.args[1..]), + args: interner.mk_args(&projection_predicate.projection_term.args.as_slice()[1..]), term: projection_predicate.term, } } @@ -578,7 +574,7 @@ impl AliasTerm { AliasTerm::new( interner, self.def_id, - [self_ty.into()].into_iter().chain(self.args.into_iter().skip(1)), + [self_ty.into()].into_iter().chain(self.args.iter().skip(1)), ) } diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs index 350d8093b8646..c803d7e179427 100644 --- a/compiler/rustc_type_ir/src/relate.rs +++ b/compiler/rustc_type_ir/src/relate.rs @@ -82,7 +82,7 @@ pub trait TypeRelation: Sized { let tcx = self.tcx(); let opt_variances = tcx.variances_of(item_def_id); - relate_args_with_variances(self, item_def_id, &opt_variances, a_arg, b_arg, true) + relate_args_with_variances(self, item_def_id, opt_variances, a_arg, b_arg, true) } /// Switch variance for the purpose of relating `a` and `b`. @@ -128,7 +128,7 @@ pub fn relate_args_invariantly>( a_arg: I::GenericArgs, b_arg: I::GenericArgs, ) -> RelateResult { - relation.tcx().mk_args_from_iter(iter::zip(a_arg, b_arg).map(|(a, b)| { + relation.tcx().mk_args_from_iter(iter::zip(a_arg.iter(), b_arg.iter()).map(|(a, b)| { relation.relate_with_variance(ty::Invariant, VarianceDiagInfo::default(), a, b) })) } @@ -136,7 +136,7 @@ pub fn relate_args_invariantly>( pub fn relate_args_with_variances>( relation: &mut R, ty_def_id: I::DefId, - variances: &[ty::Variance], + variances: I::VariancesOf, a_arg: I::GenericArgs, b_arg: I::GenericArgs, fetch_ty_for_diag: bool, @@ -144,11 +144,11 @@ pub fn relate_args_with_variances>( let tcx = relation.tcx(); let mut cached_ty = None; - let params = iter::zip(a_arg, b_arg).enumerate().map(|(i, (a, b))| { - let variance = variances[i]; + let params = iter::zip(a_arg.iter(), b_arg.iter()).enumerate().map(|(i, (a, b))| { + let variance = variances.get(i).unwrap(); let variance_info = if variance == ty::Invariant && fetch_ty_for_diag { let ty = - *cached_ty.get_or_insert_with(|| tcx.type_of(ty_def_id).instantiate(tcx, &a_arg)); + *cached_ty.get_or_insert_with(|| tcx.type_of(ty_def_id).instantiate(tcx, a_arg)); VarianceDiagInfo::Invariant { ty, param_index: i.try_into().unwrap() } } else { VarianceDiagInfo::default() @@ -249,7 +249,7 @@ impl Relate for ty::AliasTy { ty::Opaque => relate_args_with_variances( relation, a.def_id, - &relation.tcx().variances_of(a.def_id), + relation.tcx().variances_of(a.def_id), a.args, b.args, false, // do not fetch `type_of(a_def_id)`, as it will cause a cycle @@ -280,7 +280,7 @@ impl Relate for ty::AliasTerm { ty::AliasTermKind::OpaqueTy => relate_args_with_variances( relation, a.def_id, - &relation.tcx().variances_of(a.def_id), + relation.tcx().variances_of(a.def_id), a.args, b.args, false, // do not fetch `type_of(a_def_id)`, as it will cause a cycle @@ -525,7 +525,7 @@ pub fn structurally_relate_tys>( if as_.len() == bs.len() { Ok(Ty::new_tup_from_iter( tcx, - iter::zip(as_, bs).map(|(a, b)| relation.relate(a, b)), + iter::zip(as_.iter(), bs.iter()).map(|(a, b)| relation.relate(a, b)), )?) } else if !(as_.is_empty() || bs.is_empty()) { Err(TypeError::TupleSize(ExpectedFound::new(true, as_.len(), bs.len()))) @@ -607,8 +607,8 @@ pub fn structurally_relate_consts>( // be stabilized. (ty::ConstKind::Unevaluated(au), ty::ConstKind::Unevaluated(bu)) if au.def == bu.def => { if cfg!(debug_assertions) { - let a_ty = tcx.type_of(au.def).instantiate(tcx, &au.args); - let b_ty = tcx.type_of(bu.def).instantiate(tcx, &bu.args); + let a_ty = tcx.type_of(au.def).instantiate(tcx, au.args); + let b_ty = tcx.type_of(bu.def).instantiate(tcx, bu.args); assert_eq!(a_ty, b_ty); } diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs index 1c29fafc3ccac..4782b8558d78c 100644 --- a/compiler/rustc_type_ir/src/ty_kind.rs +++ b/compiler/rustc_type_ir/src/ty_kind.rs @@ -388,7 +388,7 @@ impl fmt::Debug for TyKind { Tuple(t) => { write!(f, "(")?; let mut count = 0; - for ty in *t { + for ty in t.iter() { if count > 0 { write!(f, ", ")?; } @@ -496,7 +496,7 @@ impl AliasTy { AliasTy::new( interner, self.def_id, - [self_ty.into()].into_iter().chain(self.args.into_iter().skip(1)), + [self_ty.into()].into_iter().chain(self.args.iter().skip(1)), ) } @@ -544,7 +544,7 @@ impl AliasTy { interner: I, ) -> I::GenericArgs { debug_assert_eq!(self.kind(interner), AliasTyKind::Inherent); - interner.mk_args_from_iter(impl_args.into_iter().chain(self.args.into_iter().skip(1))) + interner.mk_args_from_iter(impl_args.iter().chain(self.args.iter().skip(1))) } } diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs index 3a17a27bd03bb..04aadfdabb48d 100644 --- a/compiler/rustc_type_ir/src/ty_kind/closure.rs +++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs @@ -138,7 +138,7 @@ impl ClosureArgs { /// for the closure parent, alongside additional closure-specific components. pub fn new(tcx: I, parts: ClosureArgsParts) -> ClosureArgs { ClosureArgs { - args: tcx.mk_args_from_iter(parts.parent_args.iter().copied().chain([ + args: tcx.mk_args_from_iter(parts.parent_args.iter().chain([ parts.closure_kind_ty.into(), parts.closure_sig_as_fn_ptr_ty.into(), parts.tupled_upvars_ty.into(), @@ -260,7 +260,7 @@ pub struct CoroutineClosureArgsParts { impl CoroutineClosureArgs { pub fn new(tcx: I, parts: CoroutineClosureArgsParts) -> CoroutineClosureArgs { CoroutineClosureArgs { - args: tcx.mk_args_from_iter(parts.parent_args.iter().copied().chain([ + args: tcx.mk_args_from_iter(parts.parent_args.iter().chain([ parts.closure_kind_ty.into(), parts.signature_parts_ty.into(), parts.tupled_upvars_ty.into(), @@ -312,7 +312,7 @@ impl CoroutineClosureArgs { let [resume_ty, tupled_inputs_ty] = *sig.inputs() else { panic!(); }; - let [yield_ty, return_ty] = **sig.output().tuple_fields() else { panic!() }; + let [yield_ty, return_ty] = *sig.output().tuple_fields().as_slice() else { panic!() }; CoroutineClosureSignature { interior, tupled_inputs_ty, @@ -496,16 +496,16 @@ impl CoroutineClosureSignature { tcx, tupled_inputs_ty .tuple_fields() - .into_iter() - .chain(coroutine_captures_by_ref_ty.tuple_fields()), + .iter() + .chain(coroutine_captures_by_ref_ty.tuple_fields().iter()), ) } ty::ClosureKind::FnOnce => Ty::new_tup_from_iter( tcx, tupled_inputs_ty .tuple_fields() - .into_iter() - .chain(closure_tupled_upvars_ty.tuple_fields()), + .iter() + .chain(closure_tupled_upvars_ty.tuple_fields().iter()), ), } } @@ -617,7 +617,7 @@ impl CoroutineArgs { /// for the coroutine parent, alongside additional coroutine-specific components. pub fn new(tcx: I, parts: CoroutineArgsParts) -> CoroutineArgs { CoroutineArgs { - args: tcx.mk_args_from_iter(parts.parent_args.iter().copied().chain([ + args: tcx.mk_args_from_iter(parts.parent_args.iter().chain([ parts.kind_ty.into(), parts.resume_ty.into(), parts.yield_ty.into(), diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs index 4f99eaa40c29b..f4846a1753f7c 100644 --- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs +++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs @@ -267,7 +267,7 @@ fn needless_borrow_count<'tcx>( return false; } - let predicate = EarlyBinder::bind(predicate).instantiate(cx.tcx, &args_with_referent_ty); + let predicate = EarlyBinder::bind(predicate).instantiate(cx.tcx, &args_with_referent_ty[..]); let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate); let infcx = cx.tcx.infer_ctxt().build(); infcx.predicate_must_hold_modulo_regions(&obligation) From d521e2148e534a98f2dd2136f4ebb3d36e691056 Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Fri, 21 Jun 2024 14:07:13 -0400 Subject: [PATCH 3/3] Also migrate FnInputTys --- .../src/solve/assembly/structural_traits.rs | 14 +++++++++----- compiler/rustc_type_ir/src/interner.rs | 2 +- compiler/rustc_type_ir/src/predicate_kind.rs | 2 -- compiler/rustc_type_ir/src/relate.rs | 2 +- compiler/rustc_type_ir/src/ty_kind.rs | 2 +- compiler/rustc_type_ir/src/ty_kind/closure.rs | 2 +- 6 files changed, 13 insertions(+), 11 deletions(-) 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 d4890e48032f0..2df039c766cf5 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 @@ -258,7 +258,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable { if sig.is_fn_trait_compatible() { - Ok(Some(sig.map_bound(|sig| (Ty::new_tup(tcx, &sig.inputs()), sig.output())))) + Ok(Some( + sig.map_bound(|sig| (Ty::new_tup(tcx, sig.inputs().as_slice()), sig.output())), + )) } else { Err(NoSolution) } @@ -290,7 +292,9 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable; type Tys: Tys; - type FnInputTys: Copy + Debug + Hash + Eq + Deref + TypeVisitable; + type FnInputTys: Copy + Debug + Hash + Eq + SliceLike + TypeVisitable; type ParamTy: Copy + Debug + Hash + Eq + ParamLike; type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike; type PlaceholderTy: PlaceholderLike; diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs index efe270ed60836..b1d0f8d19b396 100644 --- a/compiler/rustc_type_ir/src/predicate_kind.rs +++ b/compiler/rustc_type_ir/src/predicate_kind.rs @@ -127,7 +127,6 @@ impl std::fmt::Display for AliasRelationDirection { } } -// FIXME: Convert to DebugWithInfcx impl impl fmt::Debug for ClauseKind { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { @@ -144,7 +143,6 @@ impl fmt::Debug for ClauseKind { } } -// FIXME: Convert to DebugWithInfcx impl impl fmt::Debug for PredicateKind { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs index c803d7e179427..0439e7f857fe7 100644 --- a/compiler/rustc_type_ir/src/relate.rs +++ b/compiler/rustc_type_ir/src/relate.rs @@ -185,7 +185,7 @@ impl Relate for ty::FnSig { } let inputs_and_output = iter::zip(a_inputs.iter(), b_inputs.iter()) - .map(|(&a, &b)| ((a, b), false)) + .map(|(a, b)| ((a, b), false)) .chain(iter::once(((a.output(), b.output()), true))) .map(|((a, b), is_output)| { if is_output { diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs index 4782b8558d78c..4ffebef9f1f9b 100644 --- a/compiler/rustc_type_ir/src/ty_kind.rs +++ b/compiler/rustc_type_ir/src/ty_kind.rs @@ -1005,7 +1005,7 @@ impl ty::Binder> { #[inline] #[track_caller] pub fn input(self, index: usize) -> ty::Binder { - self.map_bound(|fn_sig| fn_sig.inputs()[index]) + self.map_bound(|fn_sig| fn_sig.inputs().get(index).unwrap()) } pub fn inputs_and_output(self) -> ty::Binder { diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs index 04aadfdabb48d..24a7c0c67e90f 100644 --- a/compiler/rustc_type_ir/src/ty_kind/closure.rs +++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs @@ -309,7 +309,7 @@ impl CoroutineClosureArgs { let interior = self.coroutine_witness_ty(); let ty::FnPtr(sig) = self.signature_parts_ty().kind() else { panic!() }; sig.map_bound(|sig| { - let [resume_ty, tupled_inputs_ty] = *sig.inputs() else { + let [resume_ty, tupled_inputs_ty] = *sig.inputs().as_slice() else { panic!(); }; let [yield_ty, return_ty] = *sig.output().tuple_fields().as_slice() else { panic!() };