Add note when inherent impl for a alias type defined outside of the crate

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

compiler/rustc_hir_analysis/messages.ftl

@@ -236,6 +236,8 @@ hir_analysis_inherent_ty_outside_new = cannot define inherent `impl` for a type
     .label = impl for type defined outside of crate
     .note = define and implement a trait or new type instead
 
+hir_analysis_inherent_ty_outside_new_alias_note = `{$ty_name}` does not define a new type, just alias of `{$alias_ty_name}`, which defined outside of crate
+
 hir_analysis_inherent_ty_outside_primitive = cannot define inherent `impl` for primitive types outside of `core`
     .help = consider moving this inherent impl into `core` if possible
     .span_help = alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -64,6 +64,7 @@ impl<'tcx> InherentCollect<'tcx> {
     fn check_def_id(
         &mut self,
         impl_def_id: LocalDefId,
+        hir_item_id: hir::ItemId,
         self_ty: Ty<'tcx>,
         ty_def_id: DefId,
     ) -> Result<(), ErrorGuaranteed> {
@@ -103,7 +104,22 @@ impl<'tcx> InherentCollect<'tcx> {
             Ok(())
         } else {
             let impl_span = self.tcx.def_span(impl_def_id);
-            Err(self.tcx.dcx().emit_err(errors::InherentTyOutsideNew { span: impl_span }))
+            let mut err = errors::InherentTyOutsideNew { span: impl_span, note: None };
+
+            if let hir::ItemKind::Impl(impl_item) = self.tcx.hir_item(hir_item_id).kind {
+                if let hir::TyKind::Path(rustc_hir::QPath::Resolved(_, path)) =
+                    impl_item.self_ty.kind
+                {
+                    if let rustc_hir::def::Res::Def(DefKind::TyAlias, def_id) = path.res {
+                        let ty_name = self.tcx.def_path_str(def_id);
+                        let alias_ty_name = self.tcx.type_of(def_id).skip_binder().to_string();
+                        err.note =
+                            Some(errors::InherentTyOutsideNewAliasNote { ty_name, alias_ty_name });
+                    }
+                }
+            }
+
+            Err(self.tcx.dcx().emit_err(err))
         }
     }
 
@@ -142,12 +158,12 @@ impl<'tcx> InherentCollect<'tcx> {
         Ok(())
     }
 
-    fn check_item(&mut self, id: hir::ItemId) -> Result<(), ErrorGuaranteed> {
-        if !matches!(self.tcx.def_kind(id.owner_id), DefKind::Impl { of_trait: false }) {
+    fn check_item(&mut self, hir_item_id: hir::ItemId) -> Result<(), ErrorGuaranteed> {
+        if !matches!(self.tcx.def_kind(hir_item_id.owner_id), DefKind::Impl { of_trait: false }) {
             return Ok(());
         }
 
-        let id = id.owner_id.def_id;
+        let id = hir_item_id.owner_id.def_id;
         let item_span = self.tcx.def_span(id);
         let self_ty = self.tcx.type_of(id).instantiate_identity();
         let mut self_ty = self.tcx.peel_off_free_alias_tys(self_ty);
@@ -157,10 +173,10 @@ impl<'tcx> InherentCollect<'tcx> {
             self_ty = base;
         }
         match *self_ty.kind() {
-            ty::Adt(def, _) => self.check_def_id(id, self_ty, def.did()),
-            ty::Foreign(did) => self.check_def_id(id, self_ty, did),
+            ty::Adt(def, _) => self.check_def_id(id, hir_item_id, self_ty, def.did()),
+            ty::Foreign(did) => self.check_def_id(id, hir_item_id, self_ty, did),
             ty::Dynamic(data, ..) if data.principal_def_id().is_some() => {
-                self.check_def_id(id, self_ty, data.principal_def_id().unwrap())
+                self.check_def_id(id, hir_item_id, self_ty, data.principal_def_id().unwrap())
             }
             ty::Dynamic(..) => {
                 Err(self.tcx.dcx().emit_err(errors::InherentDyn { span: item_span }))

compiler/rustc_hir_analysis/src/errors.rs

@@ -1186,6 +1186,15 @@ pub(crate) struct InherentTyOutsideNew {
     #[primary_span]
     #[label]
     pub span: Span,
+    #[subdiagnostic]
+    pub note: Option<InherentTyOutsideNewAliasNote>,
+}
+
+#[derive(Subdiagnostic)]
+#[note(hir_analysis_inherent_ty_outside_new_alias_note)]
+pub(crate) struct InherentTyOutsideNewAliasNote {
+    pub ty_name: String,
+    pub alias_ty_name: String,
 }
 
 #[derive(Diagnostic)]

tests/ui/incoherent-inherent-impls/insufficient-suggestion-issue-141679.stderr

@@ -5,6 +5,7 @@ LL | impl Function {}
    | ^^^^^^^^^^^^^ impl for type defined outside of crate
    |
    = note: define and implement a trait or new type instead
+   = note: `Function` does not define a new type, just alias of `Rc<Foo>`, which defined outside of crate
 
 error: aborting due to 1 previous error