update: make each trait_impl_reduntant_assoc_item into individual diagnostic

Author: Young-Flash

crates/hir/src/diagnostics.rs

@@ -316,5 +316,5 @@ pub struct TraitImplMissingAssocItems {
 pub struct TraitImplReduntantAssocItems {
     pub file_id: HirFileId,
     pub impl_: AstPtr<ast::Impl>,
-    pub reduntant: Vec<(Name, AssocItem)>,
-}
+    pub assoc_item: (Name, AssocItem),
+}

crates/hir/src/lib.rs

@@ -685,20 +685,21 @@ impl Module {
                     },
                 ));
 
-                let reduntant: Vec<_> = impl_assoc_items_scratch.iter()
-                .filter(|(id, name)| {
-                    !required_items.clone().any(|(impl_name, impl_item)| {
-                        discriminant(impl_item) == discriminant(id) && impl_name == name
+                let reduntant: Vec<_> = impl_assoc_items_scratch
+                    .iter()
+                    .filter(|(id, name)| {
+                        !items.iter().any(|(impl_name, impl_item)| {
+                            discriminant(impl_item) == discriminant(id) && impl_name == name
+                        })
                     })
-                })
-                .map(|(item, name)| (name.clone(), AssocItem::from(*item)))
-                .collect();
-                if !reduntant.is_empty() {
+                    .map(|(item, name)| (name.clone(), AssocItem::from(*item)))
+                    .collect();
+                for (name, assoc_item) in reduntant {
                     acc.push(
                         TraitImplReduntantAssocItems {
                             impl_: ast_id_map.get(node.ast_id()),
                             file_id,
-                            reduntant,
+                            assoc_item: (name, assoc_item),
                         }
                         .into(),
                     )

crates/ide-diagnostics/src/handlers/trait_impl_reduntant_assoc_item.rs

@@ -1,8 +1,7 @@
-use hir::InFile;
-use itertools::Itertools;
-use syntax::{ast, AstNode};
+use hir::{db::ExpandDatabase, Const, Function, HasSource, TypeAlias};
+use syntax::ast;
 
-use crate::{adjusted_display_range, Diagnostic, DiagnosticCode, DiagnosticsContext};
+use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
 
 // Diagnostic: trait-impl-reduntant-assoc_item
 //
@@ -11,26 +10,53 @@ pub(crate) fn trait_impl_reduntant_assoc_item(
     ctx: &DiagnosticsContext<'_>,
     d: &hir::TraitImplReduntantAssocItems,
 ) -> Diagnostic {
-    let reduntant = d.reduntant.iter().format_with(", ", |(name, item), f| {
-        f(&match *item {
-            hir::AssocItem::Function(_) => "`fn ",
-            hir::AssocItem::Const(_) => "`const ",
-            hir::AssocItem::TypeAlias(_) => "`type ",
-        })?;
-        f(&name.display(ctx.sema.db))?;
-        f(&"`")
-    });
+    let name = d.assoc_item.0.clone();
+    let assoc_item = d.assoc_item.1;
+    let db = ctx.sema.db;
+
+    let root = ctx.sema.db.parse_or_expand(d.file_id);
+    let range = root.text_range();
+    let impl_ = d.impl_.to_node(&root);
+    let trait_name = if let Some(trait_name) = trait_name(ctx, impl_) {
+        trait_name
+    } else {
+        String::from("{unkown}")
+    };
+
+    let (reduntant_item_name, diagnostic_range) = match assoc_item {
+        hir::AssocItem::Function(id) => (
+            format!("`fn {}`", name.display(db)),
+            Function::from(id).source(db).map(|it| it.syntax().value.text_range()).unwrap_or(range),
+        ),
+        hir::AssocItem::Const(id) => (
+            format!("`const {}`", name.display(db)),
+            Const::from(id).source(db).map(|it| it.syntax().value.text_range()).unwrap_or(range),
+        ),
+        hir::AssocItem::TypeAlias(id) => (
+            format!("`type {}`", name.display(db)),
+            TypeAlias::from(id)
+                .source(db)
+                .map(|it| it.syntax().value.text_range())
+                .unwrap_or(range),
+        ),
+    };
+
     Diagnostic::new(
         DiagnosticCode::RustcHardError("E0407"),
-        format!("{reduntant} is not a member of trait"),
-        adjusted_display_range::<ast::Impl>(
-            ctx,
-            InFile { file_id: d.file_id, value: d.impl_.syntax_node_ptr() },
-            &|impl_| impl_.trait_().map(|t| t.syntax().text_range()),
-        ),
+        format!("{reduntant_item_name} is not a member of trait `{trait_name}`"),
+        diagnostic_range,
     )
 }
 
+fn trait_name(ctx: &DiagnosticsContext<'_>, impl_: ast::Impl) -> Option<String> {
+    if let ast::Type::PathType(trait_path) = impl_.trait_()? {
+        let trait_type = ctx.sema.resolve_trait(&trait_path.path()?)?;
+        Some(trait_type.name(ctx.sema.db).as_text()?.to_string())
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::check_diagnostics;
@@ -40,14 +66,20 @@ mod tests {
         check_diagnostics(
             r#"
 trait Marker {
+    const FLAG: bool = false;
     fn boo();
+    fn foo () {}
 }
 struct Foo;
 impl Marker for Foo {
-   //^^^^^^ error: `type T`, `const FLAG`, `fn bar` is not a member of trait
     type T = i32;
-    const FLAG: bool = false;
+  //^^^^^^^^^^^^^ error: `type T` is not a member of trait `Marker`
+
+    const FLAG: bool = true;
+
     fn bar() {}
+  //^^^^^^^^^^^ error: `fn bar` is not a member of trait `Marker`
+
     fn boo() {}
 }
             "#,