bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Copy ty::AssocItem all other the place

Browse source
This commit is contained in:
Maybe Waffle 2023-02-06 08:57:34 +00:00
parent 236ddf36b3
commit a32d392741
17 changed files with 89 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -537,7 +537,7 @@ fn check_item_type(tcx: TyCtxt<'_>, id: hir::ItemId) {
let assoc_items = tcx.associated_items(id.owner_id); let assoc_items = tcx.associated_items(id.owner_id);
check_on_unimplemented(tcx, id); check_on_unimplemented(tcx, id);
for assoc_item in assoc_items.in_definition_order() { for &assoc_item in assoc_items.in_definition_order() {
match assoc_item.kind { match assoc_item.kind {
ty::AssocKind::Fn => { ty::AssocKind::Fn => {
let abi = tcx.fn_sig(assoc_item.def_id).skip_binder().abi(); let abi = tcx.fn_sig(assoc_item.def_id).skip_binder().abi();
@ -670,7 +670,7 @@ pub(super) fn check_on_unimplemented(tcx: TyCtxt<'_>, item: hir::ItemId) {
pub(super) fn check_specialization_validity<'tcx>( pub(super) fn check_specialization_validity<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
trait_def: &ty::TraitDef, trait_def: &ty::TraitDef,
trait_item: &ty::AssocItem, trait_item: ty::AssocItem,
impl_id: DefId, impl_id: DefId,
impl_item: DefId, impl_item: DefId,
) { ) {
@ -767,17 +767,17 @@ fn check_impl_items_against_trait<'tcx>(
)); ));
} }
ty::AssocKind::Fn => { ty::AssocKind::Fn => {
compare_impl_method(tcx, &ty_impl_item, &ty_trait_item, impl_trait_ref); compare_impl_method(tcx, ty_impl_item, ty_trait_item, impl_trait_ref);
} }
ty::AssocKind::Type => { ty::AssocKind::Type => {
compare_impl_ty(tcx, &ty_impl_item, &ty_trait_item, impl_trait_ref); compare_impl_ty(tcx, ty_impl_item, ty_trait_item, impl_trait_ref);
} }
} }
check_specialization_validity( check_specialization_validity(
tcx, tcx,
trait_def, trait_def,
&ty_trait_item, ty_trait_item,
impl_id.to_def_id(), impl_id.to_def_id(),
impl_item, impl_item,
); );

68
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View file

@ -37,8 +37,8 @@ use std::iter;
/// - `impl_trait_ref`: the TraitRef corresponding to the trait implementation /// - `impl_trait_ref`: the TraitRef corresponding to the trait implementation
pub(super) fn compare_impl_method<'tcx>( pub(super) fn compare_impl_method<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
) { ) {
debug!("compare_impl_method(impl_trait_ref={:?})", impl_trait_ref); debug!("compare_impl_method(impl_trait_ref={:?})", impl_trait_ref);
@ -129,8 +129,8 @@ pub(super) fn compare_impl_method<'tcx>(
#[instrument(level = "debug", skip(tcx, impl_trait_ref))] #[instrument(level = "debug", skip(tcx, impl_trait_ref))]
fn compare_method_predicate_entailment<'tcx>( fn compare_method_predicate_entailment<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
check_implied_wf: CheckImpliedWfMode, check_implied_wf: CheckImpliedWfMode,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
@ -381,8 +381,8 @@ fn compare_method_predicate_entailment<'tcx>(
fn extract_bad_args_for_implies_lint<'tcx>( fn extract_bad_args_for_implies_lint<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
errors: &[infer::RegionResolutionError<'tcx>], errors: &[infer::RegionResolutionError<'tcx>],
(trait_m, trait_sig): (&ty::AssocItem, ty::FnSig<'tcx>), (trait_m, trait_sig): (ty::AssocItem, ty::FnSig<'tcx>),
(impl_m, impl_sig): (&ty::AssocItem, ty::FnSig<'tcx>), (impl_m, impl_sig): (ty::AssocItem, ty::FnSig<'tcx>),
hir_id: hir::HirId, hir_id: hir::HirId,
) -> Vec<(Span, Option<String>)> { ) -> Vec<(Span, Option<String>)> {
let mut blame_generics = vec![]; let mut blame_generics = vec![];
@ -480,7 +480,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RemapLateBound<'_, 'tcx> {
fn emit_implied_wf_lint<'tcx>( fn emit_implied_wf_lint<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
hir_id: hir::HirId, hir_id: hir::HirId,
bad_args: Vec<(Span, Option<String>)>, bad_args: Vec<(Span, Option<String>)>,
) { ) {
@ -527,8 +527,8 @@ enum CheckImpliedWfMode {
fn compare_asyncness<'tcx>( fn compare_asyncness<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
if tcx.asyncness(trait_m.def_id) == hir::IsAsync::Async { if tcx.asyncness(trait_m.def_id) == hir::IsAsync::Async {
match tcx.fn_sig(impl_m.def_id).skip_binder().skip_binder().output().kind() { match tcx.fn_sig(impl_m.def_id).skip_binder().skip_binder().output().kind() {
@ -873,8 +873,8 @@ fn report_trait_method_mismatch<'tcx>(
infcx: &InferCtxt<'tcx>, infcx: &InferCtxt<'tcx>,
mut cause: ObligationCause<'tcx>, mut cause: ObligationCause<'tcx>,
terr: TypeError<'tcx>, terr: TypeError<'tcx>,
(trait_m, trait_sig): (&ty::AssocItem, ty::FnSig<'tcx>), (trait_m, trait_sig): (ty::AssocItem, ty::FnSig<'tcx>),
(impl_m, impl_sig): (&ty::AssocItem, ty::FnSig<'tcx>), (impl_m, impl_sig): (ty::AssocItem, ty::FnSig<'tcx>),
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
) -> ErrorGuaranteed { ) -> ErrorGuaranteed {
let tcx = infcx.tcx; let tcx = infcx.tcx;
@ -967,8 +967,8 @@ fn report_trait_method_mismatch<'tcx>(
fn check_region_bounds_on_impl_item<'tcx>( fn check_region_bounds_on_impl_item<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
delay: bool, delay: bool,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
let impl_generics = tcx.generics_of(impl_m.def_id); let impl_generics = tcx.generics_of(impl_m.def_id);
@ -1042,7 +1042,7 @@ fn check_region_bounds_on_impl_item<'tcx>(
.sess .sess
.create_err(LifetimesOrBoundsMismatchOnTrait { .create_err(LifetimesOrBoundsMismatchOnTrait {
span, span,
item_kind: assoc_item_kind_str(impl_m), item_kind: assoc_item_kind_str(&impl_m),
ident: impl_m.ident(tcx), ident: impl_m.ident(tcx),
generics_span, generics_span,
bounds_span, bounds_span,
@ -1060,8 +1060,8 @@ fn extract_spans_for_error_reporting<'tcx>(
infcx: &infer::InferCtxt<'tcx>, infcx: &infer::InferCtxt<'tcx>,
terr: TypeError<'_>, terr: TypeError<'_>,
cause: &ObligationCause<'tcx>, cause: &ObligationCause<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
) -> (Span, Option<Span>) { ) -> (Span, Option<Span>) {
let tcx = infcx.tcx; let tcx = infcx.tcx;
let mut impl_args = { let mut impl_args = {
@ -1084,8 +1084,8 @@ fn extract_spans_for_error_reporting<'tcx>(
fn compare_self_type<'tcx>( fn compare_self_type<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
// Try to give more informative error messages about self typing // Try to give more informative error messages about self typing
@ -1096,7 +1096,7 @@ fn compare_self_type<'tcx>(
// inscrutable, particularly for cases where one method has no // inscrutable, particularly for cases where one method has no
// self. // self.
let self_string = |method: &ty::AssocItem| { let self_string = |method: ty::AssocItem| {
let untransformed_self_ty = match method.container { let untransformed_self_ty = match method.container {
ty::ImplContainer => impl_trait_ref.self_ty(), ty::ImplContainer => impl_trait_ref.self_ty(),
ty::TraitContainer => tcx.types.self_param, ty::TraitContainer => tcx.types.self_param,
@ -1186,8 +1186,8 @@ fn compare_self_type<'tcx>(
/// [`compare_generic_param_kinds`]. This function also does not handle lifetime parameters /// [`compare_generic_param_kinds`]. This function also does not handle lifetime parameters
fn compare_number_of_generics<'tcx>( fn compare_number_of_generics<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_: &ty::AssocItem, impl_: ty::AssocItem,
trait_: &ty::AssocItem, trait_: ty::AssocItem,
delay: bool, delay: bool,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
let trait_own_counts = tcx.generics_of(trait_.def_id).own_counts(); let trait_own_counts = tcx.generics_of(trait_.def_id).own_counts();
@ -1207,7 +1207,7 @@ fn compare_number_of_generics<'tcx>(
("const", trait_own_counts.consts, impl_own_counts.consts), ("const", trait_own_counts.consts, impl_own_counts.consts),
]; ];
let item_kind = assoc_item_kind_str(impl_); let item_kind = assoc_item_kind_str(&impl_);
let mut err_occurred = None; let mut err_occurred = None;
for (kind, trait_count, impl_count) in matchings { for (kind, trait_count, impl_count) in matchings {
@ -1329,8 +1329,8 @@ fn compare_number_of_generics<'tcx>(
fn compare_number_of_method_arguments<'tcx>( fn compare_number_of_method_arguments<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
let impl_m_fty = tcx.fn_sig(impl_m.def_id); let impl_m_fty = tcx.fn_sig(impl_m.def_id);
let trait_m_fty = tcx.fn_sig(trait_m.def_id); let trait_m_fty = tcx.fn_sig(trait_m.def_id);
@ -1409,8 +1409,8 @@ fn compare_number_of_method_arguments<'tcx>(
fn compare_synthetic_generics<'tcx>( fn compare_synthetic_generics<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem, impl_m: ty::AssocItem,
trait_m: &ty::AssocItem, trait_m: ty::AssocItem,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
// FIXME(chrisvittal) Clean up this function, list of FIXME items: // FIXME(chrisvittal) Clean up this function, list of FIXME items:
// 1. Better messages for the span labels // 1. Better messages for the span labels
@ -1563,8 +1563,8 @@ fn compare_synthetic_generics<'tcx>(
/// This function does not handle lifetime parameters /// This function does not handle lifetime parameters
fn compare_generic_param_kinds<'tcx>( fn compare_generic_param_kinds<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_item: &ty::AssocItem, impl_item: ty::AssocItem,
trait_item: &ty::AssocItem, trait_item: ty::AssocItem,
delay: bool, delay: bool,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
assert_eq!(impl_item.kind, trait_item.kind); assert_eq!(impl_item.kind, trait_item.kind);
@ -1736,8 +1736,8 @@ pub(super) fn compare_impl_const_raw(
pub(super) fn compare_impl_ty<'tcx>( pub(super) fn compare_impl_ty<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_ty: &ty::AssocItem, impl_ty: ty::AssocItem,
trait_ty: &ty::AssocItem, trait_ty: ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
) { ) {
debug!("compare_impl_type(impl_trait_ref={:?})", impl_trait_ref); debug!("compare_impl_type(impl_trait_ref={:?})", impl_trait_ref);
@ -1754,8 +1754,8 @@ pub(super) fn compare_impl_ty<'tcx>(
/// instead of associated functions. /// instead of associated functions.
fn compare_type_predicate_entailment<'tcx>( fn compare_type_predicate_entailment<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
impl_ty: &ty::AssocItem, impl_ty: ty::AssocItem,
trait_ty: &ty::AssocItem, trait_ty: ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
let impl_substs = InternalSubsts::identity_for_item(tcx, impl_ty.def_id); let impl_substs = InternalSubsts::identity_for_item(tcx, impl_ty.def_id);
@ -1855,8 +1855,8 @@ fn compare_type_predicate_entailment<'tcx>(
#[instrument(level = "debug", skip(tcx))] #[instrument(level = "debug", skip(tcx))]
pub(super) fn check_type_bounds<'tcx>( pub(super) fn check_type_bounds<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
trait_ty: &ty::AssocItem, trait_ty: ty::AssocItem,
impl_ty: &ty::AssocItem, impl_ty: ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>, impl_trait_ref: ty::TraitRef<'tcx>,
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
// Given // Given

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

@ -199,7 +199,7 @@ fn report_forbidden_specialization(tcx: TyCtxt<'_>, impl_item: DefId, parent_imp
fn missing_items_err( fn missing_items_err(
tcx: TyCtxt<'_>, tcx: TyCtxt<'_>,
impl_span: Span, impl_span: Span,
missing_items: &[&ty::AssocItem], missing_items: &[ty::AssocItem],
full_impl_span: Span, full_impl_span: Span,
) { ) {
let missing_items_msg = missing_items let missing_items_msg = missing_items
@ -225,7 +225,7 @@ fn missing_items_err(
let padding = let padding =
tcx.sess.source_map().indentation_before(sugg_sp).unwrap_or_else(|| String::new()); tcx.sess.source_map().indentation_before(sugg_sp).unwrap_or_else(|| String::new());
for trait_item in missing_items { for &trait_item in missing_items {
let snippet = suggestion_signature(trait_item, tcx); let snippet = suggestion_signature(trait_item, tcx);
let code = format!("{}{}\n{}", padding, snippet, padding); let code = format!("{}{}\n{}", padding, snippet, padding);
let msg = format!("implement the missing item: `{snippet}`"); let msg = format!("implement the missing item: `{snippet}`");
@ -272,7 +272,7 @@ fn default_body_is_unstable(
reason: Option<Symbol>, reason: Option<Symbol>,
issue: Option<NonZeroU32>, issue: Option<NonZeroU32>,
) { ) {
let missing_item_name = &tcx.associated_item(item_did).name; let missing_item_name = tcx.associated_item(item_did).name;
let use_of_unstable_library_feature_note = match reason { let use_of_unstable_library_feature_note = match reason {
Some(r) => format!("use of unstable library feature '{feature}': {r}"), Some(r) => format!("use of unstable library feature '{feature}': {r}"),
None => format!("use of unstable library feature '{feature}'"), None => format!("use of unstable library feature '{feature}'"),
@ -365,7 +365,7 @@ fn fn_sig_suggestion<'tcx>(
sig: ty::FnSig<'tcx>, sig: ty::FnSig<'tcx>,
ident: Ident, ident: Ident,
predicates: ty::GenericPredicates<'tcx>, predicates: ty::GenericPredicates<'tcx>,
assoc: &ty::AssocItem, assoc: ty::AssocItem,
) -> String { ) -> String {
let args = sig let args = sig
.inputs() .inputs()
@ -433,7 +433,7 @@ pub fn ty_kind_suggestion(ty: Ty<'_>) -> Option<&'static str> {
/// Return placeholder code for the given associated item. /// Return placeholder code for the given associated item.
/// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a /// Similar to `ty::AssocItem::suggestion`, but appropriate for use as the code snippet of a
/// structured suggestion. /// structured suggestion.
fn suggestion_signature(assoc: &ty::AssocItem, tcx: TyCtxt<'_>) -> String { fn suggestion_signature(assoc: ty::AssocItem, tcx: TyCtxt<'_>) -> String {
match assoc.kind { match assoc.kind {
ty::AssocKind::Fn => { ty::AssocKind::Fn => {
// We skip the binder here because the binder would deanonymize all // We skip the binder here because the binder would deanonymize all

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

@ -1183,7 +1183,7 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) {
/// ///
/// Assuming the defaults are used, check that all predicates (bounds on the /// Assuming the defaults are used, check that all predicates (bounds on the
/// assoc type and where clauses on the trait) hold. /// assoc type and where clauses on the trait) hold.
fn check_associated_type_bounds(wfcx: &WfCheckingCtxt<'_, '_>, item: &ty::AssocItem, span: Span) { fn check_associated_type_bounds(wfcx: &WfCheckingCtxt<'_, '_>, item: ty::AssocItem, span: Span) {
let bounds = wfcx.tcx().explicit_item_bounds(item.def_id); let bounds = wfcx.tcx().explicit_item_bounds(item.def_id);
debug!("check_associated_type_bounds: bounds={:?}", bounds); debug!("check_associated_type_bounds: bounds={:?}", bounds);
@ -1633,7 +1633,7 @@ const HELP_FOR_SELF_TYPE: &str = "consider changing to `self`, `&self`, `&mut se
fn check_method_receiver<'tcx>( fn check_method_receiver<'tcx>(
wfcx: &WfCheckingCtxt<'_, 'tcx>, wfcx: &WfCheckingCtxt<'_, 'tcx>,
fn_sig: &hir::FnSig<'_>, fn_sig: &hir::FnSig<'_>,
method: &ty::AssocItem, method: ty::AssocItem,
self_ty: Ty<'tcx>, self_ty: Ty<'tcx>,
) { ) {
let tcx = wfcx.tcx(); let tcx = wfcx.tcx();

14
compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
View file

@ -27,8 +27,8 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
/// namespace. /// namespace.
fn impls_have_common_items( fn impls_have_common_items(
&self, &self,
impl_items1: &ty::AssocItems<'_>, impl_items1: &ty::AssocItems,
impl_items2: &ty::AssocItems<'_>, impl_items2: &ty::AssocItems,
) -> bool { ) -> bool {
let mut impl_items1 = &impl_items1; let mut impl_items1 = &impl_items1;
let mut impl_items2 = &impl_items2; let mut impl_items2 = &impl_items2;
@ -38,10 +38,10 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
std::mem::swap(&mut impl_items1, &mut impl_items2); std::mem::swap(&mut impl_items1, &mut impl_items2);
} }
for item1 in impl_items1.in_definition_order() { for &item1 in impl_items1.in_definition_order() {
let collision = impl_items2 let collision = impl_items2
.filter_by_name_unhygienic(item1.name) .filter_by_name_unhygienic(item1.name)
.any(|item2| self.compare_hygienically(item1, item2)); .any(|&item2| self.compare_hygienically(item1, item2));
if collision { if collision {
return true; return true;
@ -51,7 +51,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
false false
} }
fn compare_hygienically(&self, item1: &ty::AssocItem, item2: &ty::AssocItem) -> bool { fn compare_hygienically(&self, item1: ty::AssocItem, item2: ty::AssocItem) -> bool {
// Symbols and namespace match, compare hygienically. // Symbols and namespace match, compare hygienically.
item1.kind.namespace() == item2.kind.namespace() item1.kind.namespace() == item2.kind.namespace()
&& item1.ident(self.tcx).normalize_to_macros_2_0() && item1.ident(self.tcx).normalize_to_macros_2_0()
@ -98,10 +98,10 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
let impl_items1 = self.tcx.associated_items(impl1); let impl_items1 = self.tcx.associated_items(impl1);
let impl_items2 = self.tcx.associated_items(impl2); let impl_items2 = self.tcx.associated_items(impl2);
for item1 in impl_items1.in_definition_order() { for &item1 in impl_items1.in_definition_order() {
let collision = impl_items2 let collision = impl_items2
.filter_by_name_unhygienic(item1.name) .filter_by_name_unhygienic(item1.name)
.find(|item2| self.compare_hygienically(item1, item2)); .find(|&&item2| self.compare_hygienically(item1, item2));
if let Some(item2) = collision { if let Some(item2) = collision {
let name = item1.ident(self.tcx).normalize_to_macros_2_0(); let name = item1.ident(self.tcx).normalize_to_macros_2_0();

2
compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
View file

@ -423,7 +423,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
fn get_unbound_associated_types(&self) -> Vec<String> { fn get_unbound_associated_types(&self) -> Vec<String> {
if self.tcx.is_trait(self.def_id) { if self.tcx.is_trait(self.def_id) {
let items: &AssocItems<'_> = self.tcx.associated_items(self.def_id); let items: &AssocItems = self.tcx.associated_items(self.def_id);
items items
.in_definition_order() .in_definition_order()
.filter(|item| item.kind == AssocKind::Type) .filter(|item| item.kind == AssocKind::Type)

21
compiler/rustc_hir_typeck/src/method/probe.rs
View file

@ -736,7 +736,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
debug!("impl_ty: {:?}", impl_ty); debug!("impl_ty: {:?}", impl_ty);
// Determine the receiver type that the method itself expects. // Determine the receiver type that the method itself expects.
let (xform_self_ty, xform_ret_ty) = self.xform_self_ty(&item, impl_ty, impl_substs); let (xform_self_ty, xform_ret_ty) = self.xform_self_ty(item, impl_ty, impl_substs);
debug!("xform_self_ty: {:?}, xform_ret_ty: {:?}", xform_self_ty, xform_ret_ty); debug!("xform_self_ty: {:?}, xform_ret_ty: {:?}", xform_self_ty, xform_ret_ty);
// We can't use normalize_associated_types_in as it will pollute the // We can't use normalize_associated_types_in as it will pollute the
@ -797,7 +797,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
let new_trait_ref = this.erase_late_bound_regions(new_trait_ref); let new_trait_ref = this.erase_late_bound_regions(new_trait_ref);
let (xform_self_ty, xform_ret_ty) = let (xform_self_ty, xform_ret_ty) =
this.xform_self_ty(&item, new_trait_ref.self_ty(), new_trait_ref.substs); this.xform_self_ty(item, new_trait_ref.self_ty(), new_trait_ref.substs);
this.push_candidate( this.push_candidate(
Candidate { Candidate {
xform_self_ty, xform_self_ty,
@ -846,7 +846,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
let trait_ref = this.erase_late_bound_regions(poly_trait_ref); let trait_ref = this.erase_late_bound_regions(poly_trait_ref);
let (xform_self_ty, xform_ret_ty) = let (xform_self_ty, xform_ret_ty) =
this.xform_self_ty(&item, trait_ref.self_ty(), trait_ref.substs); this.xform_self_ty(item, trait_ref.self_ty(), trait_ref.substs);
// Because this trait derives from a where-clause, it // Because this trait derives from a where-clause, it
// should not contain any inference variables or other // should not contain any inference variables or other
@ -917,7 +917,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
fn matches_return_type( fn matches_return_type(
&self, &self,
method: &ty::AssocItem, method: ty::AssocItem,
self_ty: Option<Ty<'tcx>>, self_ty: Option<Ty<'tcx>>,
expected: Ty<'tcx>, expected: Ty<'tcx>,
) -> bool { ) -> bool {
@ -966,11 +966,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
} else { } else {
let new_trait_ref = self.erase_late_bound_regions(bound_trait_ref); let new_trait_ref = self.erase_late_bound_regions(bound_trait_ref);
let (xform_self_ty, xform_ret_ty) = self.xform_self_ty( let (xform_self_ty, xform_ret_ty) =
&item, self.xform_self_ty(item, new_trait_ref.self_ty(), new_trait_ref.substs);
new_trait_ref.self_ty(),
new_trait_ref.substs,
);
self.push_candidate( self.push_candidate(
Candidate { Candidate {
xform_self_ty, xform_self_ty,
@ -998,7 +995,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
} }
let (xform_self_ty, xform_ret_ty) = let (xform_self_ty, xform_ret_ty) =
self.xform_self_ty(&item, trait_ref.self_ty(), trait_substs); self.xform_self_ty(item, trait_ref.self_ty(), trait_substs);
self.push_candidate( self.push_candidate(
Candidate { Candidate {
xform_self_ty, xform_self_ty,
@ -1025,7 +1022,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
.filter(|candidate| candidate_filter(&candidate.item)) .filter(|candidate| candidate_filter(&candidate.item))
.filter(|candidate| { .filter(|candidate| {
if let Some(return_ty) = self.return_type { if let Some(return_ty) = self.return_type {
self.matches_return_type(&candidate.item, None, return_ty) self.matches_return_type(candidate.item, None, return_ty)
} else { } else {
true true
} }
@ -1884,7 +1881,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
#[instrument(level = "debug", skip(self))] #[instrument(level = "debug", skip(self))]
fn xform_self_ty( fn xform_self_ty(
&self, &self,
item: &ty::AssocItem, item: ty::AssocItem,
impl_ty: Ty<'tcx>, impl_ty: Ty<'tcx>,
substs: SubstsRef<'tcx>, substs: SubstsRef<'tcx>,
) -> (Ty<'tcx>, Option<Ty<'tcx>>) { ) -> (Ty<'tcx>, Option<Ty<'tcx>>) {

6
compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs
View file

@ -326,7 +326,7 @@ impl<T> Trait<T> for X {
diag, diag,
&trait_ref, &trait_ref,
pred.bounds, pred.bounds,
&assoc, assoc,
assoc_substs, assoc_substs,
ty, ty,
msg, msg,
@ -622,7 +622,7 @@ fn foo(&self) -> Self::T { String::new() }
diag: &mut Diagnostic, diag: &mut Diagnostic,
trait_ref: &ty::TraitRef<'tcx>, trait_ref: &ty::TraitRef<'tcx>,
bounds: hir::GenericBounds<'_>, bounds: hir::GenericBounds<'_>,
assoc: &ty::AssocItem, assoc: ty::AssocItem,
assoc_substs: &[ty::GenericArg<'tcx>], assoc_substs: &[ty::GenericArg<'tcx>],
ty: Ty<'tcx>, ty: Ty<'tcx>,
msg: &str, msg: &str,
@ -665,7 +665,7 @@ fn foo(&self) -> Self::T { String::new() }
&self, &self,
diag: &mut Diagnostic, diag: &mut Diagnostic,
span: Span, span: Span,
assoc: &ty::AssocItem, assoc: ty::AssocItem,
assoc_substs: &[ty::GenericArg<'tcx>], assoc_substs: &[ty::GenericArg<'tcx>],
ty: Ty<'tcx>, ty: Ty<'tcx>,
msg: &str, msg: &str,

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

@ -736,7 +736,7 @@ rustc_queries! {
} }
/// Collects the associated items defined on a trait or impl. /// Collects the associated items defined on a trait or impl.
query associated_items(key: DefId) -> &'tcx ty::AssocItems<'tcx> { query associated_items(key: DefId) -> &'tcx ty::AssocItems {
arena_cache arena_cache
desc { |tcx| "collecting associated items of `{}`", tcx.def_path_str(key) } desc { |tcx| "collecting associated items of `{}`", tcx.def_path_str(key) }
} }

8
compiler/rustc_middle/src/traits/specialization_graph.rs
View file

@ -133,11 +133,7 @@ impl Node {
/// ///
/// If this returns `None`, the item can potentially still be found in /// If this returns `None`, the item can potentially still be found in
/// parents of this node. /// parents of this node.
pub fn item<'tcx>( pub fn item<'tcx>(&self, tcx: TyCtxt<'tcx>, trait_item_def_id: DefId) -> Option<ty::AssocItem> {
&self,
tcx: TyCtxt<'tcx>,
trait_item_def_id: DefId,
) -> Option<&'tcx ty::AssocItem> {
match *self { match *self {
Node::Trait(_) => Some(tcx.associated_item(trait_item_def_id)), Node::Trait(_) => Some(tcx.associated_item(trait_item_def_id)),
Node::Impl(impl_def_id) => { Node::Impl(impl_def_id) => {
@ -239,7 +235,7 @@ impl<'tcx> Ancestors<'tcx> {
} }
} }
Some(LeafDef { item: *item, defining_node: node, finalizing_node }) Some(LeafDef { item, defining_node: node, finalizing_node })
} else { } else {
// Item not mentioned. This "finalizes" any defaulted item provided by an ancestor. // Item not mentioned. This "finalizes" any defaulted item provided by an ancestor.
finalizing_node = Some(node); finalizing_node = Some(node);

12
compiler/rustc_middle/src/ty/assoc.rs
View file

@ -129,13 +129,13 @@ impl std::fmt::Display for AssocKind {
/// it is relatively expensive. Instead, items are indexed by `Symbol` and hygienic comparison is /// it is relatively expensive. Instead, items are indexed by `Symbol` and hygienic comparison is
/// done only on items with the same name. /// done only on items with the same name.
#[derive(Debug, Clone, PartialEq, HashStable)] #[derive(Debug, Clone, PartialEq, HashStable)]
pub struct AssocItems<'tcx> { pub struct AssocItems {
items: SortedIndexMultiMap<u32, Symbol, &'tcx ty::AssocItem>, items: SortedIndexMultiMap<u32, Symbol, ty::AssocItem>,
} }
impl<'tcx> AssocItems<'tcx> { impl AssocItems {
/// Constructs an `AssociatedItems` map from a series of `ty::AssocItem`s in definition order. /// Constructs an `AssociatedItems` map from a series of `ty::AssocItem`s in definition order.
pub fn new(items_in_def_order: impl IntoIterator<Item = &'tcx ty::AssocItem>) -> Self { pub fn new(items_in_def_order: impl IntoIterator<Item = ty::AssocItem>) -> Self {
let items = items_in_def_order.into_iter().map(|item| (item.name, item)).collect(); let items = items_in_def_order.into_iter().map(|item| (item.name, item)).collect();
AssocItems { items } AssocItems { items }
} }
@ -145,7 +145,7 @@ impl<'tcx> AssocItems<'tcx> {
/// New code should avoid relying on definition order. If you need a particular associated item /// New code should avoid relying on definition order. If you need a particular associated item
/// for a known trait, make that trait a lang item instead of indexing this array. /// for a known trait, make that trait a lang item instead of indexing this array.
pub fn in_definition_order(&self) -> impl '_ + Iterator<Item = &ty::AssocItem> { pub fn in_definition_order(&self) -> impl '_ + Iterator<Item = &ty::AssocItem> {
self.items.iter().map(|(_, v)| *v) self.items.iter().map(|(_, v)| v)
} }
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
@ -157,7 +157,7 @@ impl<'tcx> AssocItems<'tcx> {
&self, &self,
name: Symbol, name: Symbol,
) -> impl '_ + Iterator<Item = &ty::AssocItem> { ) -> impl '_ + Iterator<Item = &ty::AssocItem> {
self.items.get_by_key(name).copied() self.items.get_by_key(name)
} }
/// Returns the associated item with the given name and `AssocKind`, if one exists. /// Returns the associated item with the given name and `AssocKind`, if one exists.

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

@ -2198,7 +2198,7 @@ impl<'tcx> TyCtxt<'tcx> {
Some(Ident::new(def, span)) Some(Ident::new(def, span))
} }
pub fn opt_associated_item(self, def_id: DefId) -> Option<&'tcx AssocItem> { pub fn opt_associated_item(self, def_id: DefId) -> Option<AssocItem> {
if let DefKind::AssocConst | DefKind::AssocFn | DefKind::AssocTy = self.def_kind(def_id) { if let DefKind::AssocConst | DefKind::AssocFn | DefKind::AssocTy = self.def_kind(def_id) {
Some(self.associated_item(def_id)) Some(self.associated_item(def_id))
} else { } else {

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

@ -97,7 +97,7 @@ fn check_is_object_safe(tcx: TyCtxt<'_>, trait_def_id: DefId) -> bool {
/// object. Note that object-safe traits can have some /// object. Note that object-safe traits can have some
/// non-vtable-safe methods, so long as they require `Self: Sized` or /// non-vtable-safe methods, so long as they require `Self: Sized` or
/// otherwise ensure that they cannot be used when `Self = Trait`. /// otherwise ensure that they cannot be used when `Self = Trait`.
pub fn is_vtable_safe_method(tcx: TyCtxt<'_>, trait_def_id: DefId, method: &ty::AssocItem) -> bool { pub fn is_vtable_safe_method(tcx: TyCtxt<'_>, trait_def_id: DefId, method: ty::AssocItem) -> bool {
debug_assert!(tcx.generics_of(trait_def_id).has_self); debug_assert!(tcx.generics_of(trait_def_id).has_self);
debug!("is_vtable_safe_method({:?}, {:?})", trait_def_id, method); debug!("is_vtable_safe_method({:?}, {:?})", trait_def_id, method);
// Any method that has a `Self: Sized` bound cannot be called. // Any method that has a `Self: Sized` bound cannot be called.
@ -120,8 +120,8 @@ fn object_safety_violations_for_trait(
.associated_items(trait_def_id) .associated_items(trait_def_id)
.in_definition_order() .in_definition_order()
.filter(|item| item.kind == ty::AssocKind::Fn) .filter(|item| item.kind == ty::AssocKind::Fn)
.filter_map(|item| { .filter_map(|&item| {
object_safety_violation_for_method(tcx, trait_def_id, &item) object_safety_violation_for_method(tcx, trait_def_id, item)
.map(|(code, span)| ObjectSafetyViolation::Method(item.name, code, span)) .map(|(code, span)| ObjectSafetyViolation::Method(item.name, code, span))
}) })
.collect(); .collect();
@ -382,7 +382,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
fn object_safety_violation_for_method( fn object_safety_violation_for_method(
tcx: TyCtxt<'_>, tcx: TyCtxt<'_>,
trait_def_id: DefId, trait_def_id: DefId,
method: &ty::AssocItem, method: ty::AssocItem,
) -> Option<(MethodViolationCode, Span)> { ) -> Option<(MethodViolationCode, Span)> {
debug!("object_safety_violation_for_method({:?}, {:?})", trait_def_id, method); debug!("object_safety_violation_for_method({:?}, {:?})", trait_def_id, method);
// Any method that has a `Self : Sized` requisite is otherwise // Any method that has a `Self : Sized` requisite is otherwise
@ -415,7 +415,7 @@ fn object_safety_violation_for_method(
fn virtual_call_violation_for_method<'tcx>( fn virtual_call_violation_for_method<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
trait_def_id: DefId, trait_def_id: DefId,
method: &ty::AssocItem, method: ty::AssocItem,
) -> Option<MethodViolationCode> { ) -> Option<MethodViolationCode> {
let sig = tcx.fn_sig(method.def_id).subst_identity(); let sig = tcx.fn_sig(method.def_id).subst_identity();
@ -718,7 +718,7 @@ fn object_ty_for_trait<'tcx>(
#[allow(dead_code)] #[allow(dead_code)]
fn receiver_is_dispatchable<'tcx>( fn receiver_is_dispatchable<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
method: &ty::AssocItem, method: ty::AssocItem,
receiver_ty: Ty<'tcx>, receiver_ty: Ty<'tcx>,
) -> bool { ) -> bool {
debug!("receiver_is_dispatchable: method = {:?}, receiver_ty = {:?}", method, receiver_ty); debug!("receiver_is_dispatchable: method = {:?}, receiver_ty = {:?}", method, receiver_ty);

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

@ -2149,7 +2149,7 @@ fn confirm_impl_candidate<'cx, 'tcx>(
} else { } else {
ty.map_bound(|ty| ty.into()) ty.map_bound(|ty| ty.into())
}; };
if !check_substs_compatible(tcx, &assoc_ty.item, substs) { if !check_substs_compatible(tcx, assoc_ty.item, substs) {
let err = tcx.ty_error_with_message( let err = tcx.ty_error_with_message(
obligation.cause.span, obligation.cause.span,
"impl item and trait item have different parameters", "impl item and trait item have different parameters",
@ -2164,7 +2164,7 @@ fn confirm_impl_candidate<'cx, 'tcx>(
// Verify that the trait item and its implementation have compatible substs lists // Verify that the trait item and its implementation have compatible substs lists
fn check_substs_compatible<'tcx>( fn check_substs_compatible<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
assoc_item: &ty::AssocItem, assoc_item: ty::AssocItem,
substs: ty::SubstsRef<'tcx>, substs: ty::SubstsRef<'tcx>,
) -> bool { ) -> bool {
fn check_substs_compatible_inner<'tcx>( fn check_substs_compatible_inner<'tcx>(
@ -2238,7 +2238,7 @@ fn confirm_impl_trait_in_trait_candidate<'tcx>(
leaf_def.defining_node, leaf_def.defining_node,
); );
if !check_substs_compatible(tcx, &leaf_def.item, impl_fn_substs) { if !check_substs_compatible(tcx, leaf_def.item, impl_fn_substs) {
let err = tcx.ty_error_with_message( let err = tcx.ty_error_with_message(
obligation.cause.span, obligation.cause.span,
"impl method and trait method have different parameters", "impl method and trait method have different parameters",

2
compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
View file

@ -399,7 +399,7 @@ pub(crate) fn assoc_def(
// If there is no such item in that impl, this function will fail with a // If there is no such item in that impl, this function will fail with a
// cycle error if the specialization graph is currently being built. // cycle error if the specialization graph is currently being built.
if let Some(&impl_item_id) = tcx.impl_item_implementor_ids(impl_def_id).get(&assoc_def_id) { if let Some(&impl_item_id) = tcx.impl_item_implementor_ids(impl_def_id).get(&assoc_def_id) {
let &item = tcx.associated_item(impl_item_id); let item = tcx.associated_item(impl_item_id);
let impl_node = Node::Impl(impl_def_id); let impl_node = Node::Impl(impl_def_id);
return Ok(LeafDef { return Ok(LeafDef {
item, item,

4
compiler/rustc_trait_selection/src/traits/vtable.rs
View file

@ -197,12 +197,12 @@ fn own_existential_vtable_entries(tcx: TyCtxt<'_>, trait_def_id: DefId) -> &[Def
.in_definition_order() .in_definition_order()
.filter(|item| item.kind == ty::AssocKind::Fn); .filter(|item| item.kind == ty::AssocKind::Fn);
// Now list each method's DefId (for within its trait). // Now list each method's DefId (for within its trait).
let own_entries = trait_methods.filter_map(move |trait_method| { let own_entries = trait_methods.filter_map(move |&trait_method| {
debug!("own_existential_vtable_entry: trait_method={:?}", trait_method); debug!("own_existential_vtable_entry: trait_method={:?}", trait_method);
let def_id = trait_method.def_id; let def_id = trait_method.def_id;
// Some methods cannot be called on an object; skip those. // Some methods cannot be called on an object; skip those.
if !is_vtable_safe_method(tcx, trait_def_id, &trait_method) { if !is_vtable_safe_method(tcx, trait_def_id, trait_method) {
debug!("own_existential_vtable_entry: not vtable safe"); debug!("own_existential_vtable_entry: not vtable safe");
return None; return None;
} }

2
compiler/rustc_ty_utils/src/assoc.rs
View file

@ -26,7 +26,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] {
} }
} }
fn associated_items(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItems<'_> { fn associated_items(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItems {
if tcx.is_trait_alias(def_id) { if tcx.is_trait_alias(def_id) {
ty::AssocItems::new(Vec::new()) ty::AssocItems::new(Vec::new())
} else { } else {