Clarify private field autoderef notes

Author: chenyukang

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -22,8 +22,10 @@ use rustc_hir::{
     expr_needs_parens,
 };
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, InferOk};
+use rustc_infer::traits::ImplSource;
 use rustc_middle::middle::privacy::Level;
 use rustc_middle::traits::IsConstable;
+use rustc_middle::ty::adjustment::{Adjust, DerefAdjustKind};
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::print::{
     PrintPolyTraitPredicateExt as _, PrintPolyTraitRefExt, PrintTraitPredicateExt as _,
@@ -49,7 +51,7 @@ use crate::error_reporting::TypeErrCtxt;
 use crate::errors;
 use crate::infer::InferCtxtExt as _;
 use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
-use crate::traits::{ImplDerivedCause, NormalizeExt, ObligationCtxt};
+use crate::traits::{ImplDerivedCause, NormalizeExt, ObligationCtxt, SelectionContext};
 
 #[derive(Debug)]
 pub enum CoroutineInteriorOrUpvar {
@@ -326,7 +328,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         }
 
         let fn_body_hir_id = self.tcx.local_def_id_to_hir_id(typeck_results.hir_owner.def_id);
-        let mut private_candidate = None;
+        let mut private_candidate: Option<(Ty<'tcx>, Ty<'tcx>, Span)> = None;
 
         for (deref_base_ty, _) in (self.autoderef_steps)(base_ty) {
             let ty::Adt(base_def, args) = deref_base_ty.kind() else {
@@ -347,20 +349,107 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             else {
                 continue;
             };
+            let field_span = self
+                .tcx
+                .def_ident_span(field_def.did)
+                .unwrap_or_else(|| self.tcx.def_span(field_def.did));
 
             if field_def.vis.is_accessible_from(def_scope, self.tcx) {
                 let accessible_field_ty = field_def.ty(self.tcx, args);
-                if let Some((private_base_ty, private_field_ty)) = private_candidate
+                if let Some((private_base_ty, private_field_ty, private_field_span)) =
+                    private_candidate
                     && !self.can_eq(param_env, private_field_ty, accessible_field_ty)
                 {
-                    err.note(format!(
-                        "there is a field `{field_ident}` on `{private_base_ty}` with type `{private_field_ty}`, but it is private"
-                    ));
+                    let private_struct_span = match private_base_ty.kind() {
+                        ty::Adt(private_base_def, _) => self
+                            .tcx
+                            .def_ident_span(private_base_def.did())
+                            .unwrap_or_else(|| self.tcx.def_span(private_base_def.did())),
+                        _ => DUMMY_SP,
+                    };
+                    let accessible_struct_span = self
+                        .tcx
+                        .def_ident_span(base_def.did())
+                        .unwrap_or_else(|| self.tcx.def_span(base_def.did()));
+                    let deref_impl_span = (typeck_results
+                        .expr_adjustments(base_expr)
+                        .iter()
+                        .filter(|adj| {
+                            matches!(adj.kind, Adjust::Deref(DerefAdjustKind::Overloaded(_)))
+                        })
+                        .count()
+                        == 1)
+                        .then(|| {
+                            self.probe(|_| {
+                                let deref_trait_did =
+                                    self.tcx.require_lang_item(LangItem::Deref, DUMMY_SP);
+                                let trait_ref =
+                                    ty::TraitRef::new(self.tcx, deref_trait_did, [private_base_ty]);
+                                let obligation: Obligation<'tcx, ty::Predicate<'tcx>> =
+                                    Obligation::new(
+                                        self.tcx,
+                                        ObligationCause::dummy(),
+                                        param_env,
+                                        trait_ref,
+                                    );
+                                let Ok(Some(ImplSource::UserDefined(impl_data))) =
+                                    SelectionContext::new(self)
+                                        .select(&obligation.with(self.tcx, trait_ref))
+                                else {
+                                    return None;
+                                };
+                                Some(self.tcx.def_span(impl_data.impl_def_id))
+                            })
+                        })
+                        .flatten();
+
+                    let mut note_spans: MultiSpan = private_struct_span.into();
+                    if private_struct_span != DUMMY_SP {
+                        note_spans.push_span_label(private_struct_span, "in this struct");
+                    }
+                    if private_field_span != DUMMY_SP {
+                        note_spans.push_span_label(
+                            private_field_span,
+                            "if this field wasn't private, it would be accessible",
+                        );
+                    }
+                    if accessible_struct_span != DUMMY_SP {
+                        note_spans.push_span_label(
+                            accessible_struct_span,
+                            "this struct is accessible through auto-deref",
+                        );
+                    }
+                    if field_span != DUMMY_SP {
+                        note_spans
+                            .push_span_label(field_span, "this is the field that was accessed");
+                    }
+                    if let Some(deref_impl_span) = deref_impl_span
+                        && deref_impl_span != DUMMY_SP
+                    {
+                        note_spans.push_span_label(
+                            deref_impl_span,
+                            "the field was accessed through this `Deref`",
+                        );
+                    }
+
+                    err.span_note(
+                        note_spans,
+                        format!(
+                            "there is a field `{field_ident}` on `{private_base_ty}` with type `{private_field_ty}` but it is private; `{field_ident}` from `{deref_base_ty}` was accessed through auto-deref instead"
+                        ),
+                    );
                 }
+
+                // we finally get to the accessible field,
+                // so we can return early without checking the rest of the autoderef candidates
                 return;
             }
 
-            private_candidate.get_or_insert((deref_base_ty, field_def.ty(self.tcx, args)));
+            private_candidate.get_or_insert((
+                deref_base_ty,
+                field_def.ty(self.tcx, args),
+                field_span,
+            ));
         }
     }
 

tests/ui/privacy/private-field-deref-confusion-issue-149546.rs

@@ -1,6 +1,7 @@
 // Field lookup still resolves to the public field on the Deref target, but
 // follow-up diagnostics should explain that the original type has a same-named
 // private field with a different type.
+//@ dont-require-annotations: ERROR
 
 mod structs {
     pub struct A {
@@ -24,114 +25,64 @@ mod structs {
 use structs::A;
 
 fn takes_usize(_: usize) {}
-//~^ NOTE function defined here
 
 trait Marker {}
 
 impl Marker for usize {}
-//~^ HELP the trait `Marker` is implemented for `usize`
 
 struct Wrapper(i32);
 
 impl<T: Marker> std::ops::Add<T> for Wrapper {
-    //~^ NOTE required for `Wrapper` to implement `Add<bool>`
-    //~| NOTE unsatisfied trait bound introduced here
     type Output = ();
 
     fn add(self, _: T) {}
 }
 
 fn by_value(a: A) {
     a.field + 5;
-    //~^ ERROR cannot add `{integer}` to `bool`
-    //~| NOTE bool
-    //~| NOTE {integer}
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn by_ref(a: &A) {
     a.field + 5;
-    //~^ ERROR cannot add `{integer}` to `bool`
-    //~| NOTE bool
-    //~| NOTE {integer}
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn rhs_by_value(a: A) {
     5 + a.field;
-    //~^ ERROR cannot add `bool` to `{integer}`
-    //~| NOTE no implementation for `{integer} + bool`
-    //~| HELP the trait `Add<bool>` is not implemented for `{integer}`
-    //~| HELP the following other types implement trait `Add<Rhs>`:
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn rhs_by_ref(a: &A) {
     5 + a.field;
-    //~^ ERROR cannot add `bool` to `{integer}`
-    //~| NOTE no implementation for `{integer} + bool`
-    //~| HELP the trait `Add<bool>` is not implemented for `{integer}`
-    //~| HELP the following other types implement trait `Add<Rhs>`:
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn rhs_assign_op_by_value(a: A) {
     let mut n = 5;
     n += a.field;
-    //~^ ERROR cannot add-assign `bool` to `{integer}`
-    //~| NOTE no implementation for `{integer} += bool`
-    //~| HELP the trait `AddAssign<bool>` is not implemented for `{integer}`
-    //~| HELP the following other types implement trait `AddAssign<Rhs>`:
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn rhs_assign_op_by_ref(a: &A) {
     let mut n = 5;
     n += a.field;
-    //~^ ERROR cannot add-assign `bool` to `{integer}`
-    //~| NOTE no implementation for `{integer} += bool`
-    //~| HELP the trait `AddAssign<bool>` is not implemented for `{integer}`
-    //~| HELP the following other types implement trait `AddAssign<Rhs>`:
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn rhs_nested_obligation(a: A) {
     Wrapper(5) + a.field;
-    //~^ ERROR the trait bound `bool: Marker` is not satisfied
-    //~| NOTE the trait `Marker` is not implemented for `bool`
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn method_call(a: A) {
     a.field.count_ones();
-    //~^ ERROR no method named `count_ones` found for type `bool` in the current scope
-    //~| NOTE method not found in `bool`
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn type_mismatch(a: A) {
     let value: usize = a.field;
-    //~^ ERROR mismatched types
-    //~| NOTE expected `usize`, found `bool`
-    //~| NOTE expected due to this
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
     eprintln!("value: {value}");
 }
 
 fn function_arg(a: A) {
     takes_usize(a.field);
-    //~^ ERROR mismatched types
-    //~| NOTE expected `usize`, found `bool`
-    //~| NOTE arguments to this function are incorrect
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn return_value(a: &A) -> usize {
-    //~^ NOTE expected `usize` because of return type
     a.field
-    //~^ ERROR mismatched types
-    //~| NOTE expected `usize`, found `bool`
-    //~| NOTE there is a field `field` on `A` with type `usize`, but it is private
 }
 
 fn main() {}