diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 8a6a2aceedd2f..124ed637d236c 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2286,7 +2286,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             colon_span: param.colon_span.map(|s| self.lower_span(s)),
             source,
         };
-        self.lower_attrs(hir_id, param_attrs, param_span, Target::from_generic_param(&param));
+        self.lower_attrs(hir_id, param_attrs, param_span, Target::from(&param));
         param
     }
 
diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
index a59b30ebf2748..2097e860468ec 100644
--- a/compiler/rustc_hir/src/target.rs
+++ b/compiler/rustc_hir/src/target.rs
@@ -7,7 +7,7 @@ use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
 use rustc_macros::StableHash;
 
 use crate::def::DefKind;
-use crate::{Item, ItemKind, TraitItem, TraitItemKind, hir};
+use crate::{self as hir, ItemKind, TraitItemKind};
 
 #[derive(Copy, Clone, PartialEq, Debug, Eq, StableHash)]
 pub enum GenericParamKind {
@@ -124,51 +124,6 @@ impl Target {
             | Target::Break => false,
         }
     }
-
-    pub fn from_item(item: &Item<'_>) -> Target {
-        match item.kind {
-            ItemKind::ExternCrate(..) => Target::ExternCrate,
-            ItemKind::Use(..) => Target::Use,
-            ItemKind::Static { .. } => Target::Static,
-            ItemKind::Const(..) => Target::Const,
-            ItemKind::Fn { .. } => Target::Fn,
-            ItemKind::Macro(..) => Target::MacroDef,
-            ItemKind::Mod(..) => Target::Mod,
-            ItemKind::ForeignMod { .. } => Target::ForeignMod,
-            ItemKind::GlobalAsm { .. } => Target::GlobalAsm,
-            ItemKind::TyAlias(..) => Target::TyAlias,
-            ItemKind::Enum(..) => Target::Enum,
-            ItemKind::Struct(..) => Target::Struct,
-            ItemKind::Union(..) => Target::Union,
-            ItemKind::Trait { .. } => Target::Trait,
-            ItemKind::TraitAlias(..) => Target::TraitAlias,
-            ItemKind::Impl(imp_) => Target::Impl { of_trait: imp_.of_trait.is_some() },
-        }
-    }
-
-    // FIXME: For now, should only be used with def_kinds from ItemIds
-    pub fn from_def_kind(def_kind: DefKind) -> Target {
-        match def_kind {
-            DefKind::ExternCrate => Target::ExternCrate,
-            DefKind::Use => Target::Use,
-            DefKind::Static { .. } => Target::Static,
-            DefKind::Const { .. } => Target::Const,
-            DefKind::Fn => Target::Fn,
-            DefKind::Macro(..) => Target::MacroDef,
-            DefKind::Mod => Target::Mod,
-            DefKind::ForeignMod => Target::ForeignMod,
-            DefKind::GlobalAsm => Target::GlobalAsm,
-            DefKind::TyAlias => Target::TyAlias,
-            DefKind::Enum => Target::Enum,
-            DefKind::Struct => Target::Struct,
-            DefKind::Union => Target::Union,
-            DefKind::Trait => Target::Trait,
-            DefKind::TraitAlias => Target::TraitAlias,
-            DefKind::Impl { of_trait } => Target::Impl { of_trait },
-            _ => panic!("impossible case reached"),
-        }
-    }
-
     pub fn from_ast_item(item: &ast::Item) -> Target {
         match item.kind {
             ast::ItemKind::ExternCrate(..) => Target::ExternCrate,
@@ -203,43 +158,6 @@ impl Target {
         }
     }
 
-    pub fn from_trait_item(trait_item: &TraitItem<'_>) -> Target {
-        match trait_item.kind {
-            TraitItemKind::Const(..) => Target::AssocConst,
-            TraitItemKind::Fn(_, hir::TraitFn::Required(_)) => {
-                Target::Method(MethodKind::Trait { body: false })
-            }
-            TraitItemKind::Fn(_, hir::TraitFn::Provided(_)) => {
-                Target::Method(MethodKind::Trait { body: true })
-            }
-            TraitItemKind::Type(..) => Target::AssocTy,
-        }
-    }
-
-    pub fn from_foreign_item(foreign_item: &hir::ForeignItem<'_>) -> Target {
-        match foreign_item.kind {
-            hir::ForeignItemKind::Fn(..) => Target::ForeignFn,
-            hir::ForeignItemKind::Static(..) => Target::ForeignStatic,
-            hir::ForeignItemKind::Type => Target::ForeignTy,
-        }
-    }
-
-    pub fn from_generic_param(generic_param: &hir::GenericParam<'_>) -> Target {
-        match generic_param.kind {
-            hir::GenericParamKind::Type { default, .. } => Target::GenericParam {
-                kind: GenericParamKind::Type,
-                has_default: default.is_some(),
-            },
-            hir::GenericParamKind::Lifetime { .. } => {
-                Target::GenericParam { kind: GenericParamKind::Lifetime, has_default: false }
-            }
-            hir::GenericParamKind::Const { default, .. } => Target::GenericParam {
-                kind: GenericParamKind::Const,
-                has_default: default.is_some(),
-            },
-        }
-    }
-
     pub fn from_assoc_item_kind(kind: &ast::AssocItemKind, assoc_ctxt: AssocCtxt) -> Target {
         match kind {
             AssocItemKind::Const(_) => Target::AssocConst,
@@ -381,3 +299,93 @@ impl Target {
         }
     }
 }
+
+impl From<&hir::ForeignItem<'_>> for Target {
+    fn from(foreign_item: &hir::ForeignItem<'_>) -> Target {
+        match foreign_item.kind {
+            hir::ForeignItemKind::Fn(..) => Target::ForeignFn,
+            hir::ForeignItemKind::Static(..) => Target::ForeignStatic,
+            hir::ForeignItemKind::Type => Target::ForeignTy,
+        }
+    }
+}
+
+impl From<&hir::GenericParam<'_>> for Target {
+    fn from(generic_param: &hir::GenericParam<'_>) -> Target {
+        match generic_param.kind {
+            hir::GenericParamKind::Type { default, .. } => Target::GenericParam {
+                kind: GenericParamKind::Type,
+                has_default: default.is_some(),
+            },
+            hir::GenericParamKind::Lifetime { .. } => {
+                Target::GenericParam { kind: GenericParamKind::Lifetime, has_default: false }
+            }
+            hir::GenericParamKind::Const { default, .. } => Target::GenericParam {
+                kind: GenericParamKind::Const,
+                has_default: default.is_some(),
+            },
+        }
+    }
+}
+
+impl From<&hir::TraitItem<'_>> for Target {
+    fn from(trait_item: &hir::TraitItem<'_>) -> Target {
+        match trait_item.kind {
+            TraitItemKind::Const(..) => Target::AssocConst,
+            TraitItemKind::Fn(_, hir::TraitFn::Required(_)) => {
+                Target::Method(MethodKind::Trait { body: false })
+            }
+            TraitItemKind::Fn(_, hir::TraitFn::Provided(_)) => {
+                Target::Method(MethodKind::Trait { body: true })
+            }
+            TraitItemKind::Type(..) => Target::AssocTy,
+        }
+    }
+}
+
+impl From<DefKind> for Target {
+    fn from(def_kind: DefKind) -> Target {
+        match def_kind {
+            DefKind::ExternCrate => Target::ExternCrate,
+            DefKind::Use => Target::Use,
+            DefKind::Static { .. } => Target::Static,
+            DefKind::Const { .. } => Target::Const,
+            DefKind::Fn => Target::Fn,
+            DefKind::Macro(..) => Target::MacroDef,
+            DefKind::Mod => Target::Mod,
+            DefKind::ForeignMod => Target::ForeignMod,
+            DefKind::GlobalAsm => Target::GlobalAsm,
+            DefKind::TyAlias => Target::TyAlias,
+            DefKind::Enum => Target::Enum,
+            DefKind::Struct => Target::Struct,
+            DefKind::Union => Target::Union,
+            DefKind::Trait => Target::Trait,
+            DefKind::TraitAlias => Target::TraitAlias,
+            DefKind::Impl { of_trait } => Target::Impl { of_trait },
+            _ => panic!("impossible case reached"),
+        }
+    }
+}
+
+impl From<&hir::Item<'_>> for Target {
+    fn from(item: &hir::Item<'_>) -> Target {
+        match item.kind {
+            ItemKind::ExternCrate(..) => Target::ExternCrate,
+            ItemKind::Use(..) => Target::Use,
+            ItemKind::Static { .. } => Target::Static,
+            ItemKind::Const(..) => Target::Const,
+            ItemKind::Fn { .. } => Target::Fn,
+            ItemKind::Macro(..) => Target::MacroDef,
+            ItemKind::Mod(..) => Target::Mod,
+            ItemKind::ForeignMod { .. } => Target::ForeignMod,
+            ItemKind::GlobalAsm { .. } => Target::GlobalAsm,
+            ItemKind::TyAlias(..) => Target::TyAlias,
+            ItemKind::Enum(..) => Target::Enum,
+            ItemKind::Struct(..) => Target::Struct,
+            ItemKind::Union(..) => Target::Union,
+            ItemKind::Trait { .. } => Target::Trait,
+            ItemKind::TraitAlias(..) => Target::TraitAlias,
+            ItemKind::Impl(imp_) => Target::Impl { of_trait: imp_.of_trait.is_some() },
+        }
+    }
+}
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 572d9cd1da957..040300ff3ef44 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1688,7 +1688,7 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
             }
         }
 
-        let target = Target::from_item(item);
+        let target = Target::from(item);
         self.check_attributes(item.hir_id(), item.span, target, Some(item));
         intravisit::walk_item(self, item)
     }
@@ -1704,13 +1704,13 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
     }
 
     fn visit_generic_param(&mut self, generic_param: &'tcx hir::GenericParam<'tcx>) {
-        let target = Target::from_generic_param(generic_param);
+        let target = Target::from(generic_param);
         self.check_attributes(generic_param.hir_id, generic_param.span, target, None);
         intravisit::walk_generic_param(self, generic_param)
     }
 
     fn visit_trait_item(&mut self, trait_item: &'tcx TraitItem<'tcx>) {
-        let target = Target::from_trait_item(trait_item);
+        let target = Target::from(trait_item);
         self.check_attributes(trait_item.hir_id(), trait_item.span, target, None);
         intravisit::walk_trait_item(self, trait_item)
     }
@@ -1726,7 +1726,7 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
     }
 
     fn visit_foreign_item(&mut self, f_item: &'tcx ForeignItem<'tcx>) {
-        let target = Target::from_foreign_item(f_item);
+        let target = Target::from(f_item);
         self.check_attributes(f_item.hir_id(), f_item.span, target, None);
         intravisit::walk_foreign_item(self, f_item)
     }