Improved Target type

- Added a few more variants which are needed for various attributes
- Previously a trait method with default block had the same target representation as a method in a `impl trait for` block, this has been changed (See `MethodKind`)
- Added both `singular_name` and `plural_name` for more precision on the form of the name

Author: JonathanBrouwer

compiler/rustc_hir/src/target.rs

@@ -6,23 +6,33 @@
 
 use std::fmt::{self, Display};
 
+use rustc_ast::visit::AssocCtxt;
+use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
+
 use crate::def::DefKind;
 use crate::{Item, ItemKind, TraitItem, TraitItemKind, hir};
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Eq)]
 pub enum GenericParamKind {
     Type,
     Lifetime,
     Const,
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Eq)]
 pub enum MethodKind {
-    Trait { body: bool },
+    /// Method in a `trait Trait` block
+    Trait {
+        /// Whether a default is provided for this method
+        body: bool,
+    },
+    /// Method in a `impl Trait for Type` block
+    TraitImpl,
+    /// Method in a `impl Type` block
     Inherent,
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Eq)]
 pub enum Target {
     ExternCrate,
     Use,
@@ -57,11 +67,14 @@ pub enum Target {
     PatField,
     ExprField,
     WherePredicate,
+    MacroCall,
+    Crate,
+    Delegation,
 }
 
 impl Display for Target {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", Self::name(*self))
+        write!(f, "{}", Self::plural_name(*self))
     }
 }
 
@@ -98,7 +111,10 @@ impl Target {
             | Target::Param
             | Target::PatField
             | Target::ExprField
-            | Target::WherePredicate => false,
+            | Target::MacroCall
+            | Target::Crate
+            | Target::WherePredicate
+            | Target::Delegation => false,
         }
     }
 
@@ -146,6 +162,39 @@ impl Target {
         }
     }
 
+    pub fn from_ast_item(item: &ast::Item) -> Target {
+        match item.kind {
+            ast::ItemKind::ExternCrate(..) => Target::ExternCrate,
+            ast::ItemKind::Use(..) => Target::Use,
+            ast::ItemKind::Static { .. } => Target::Static,
+            ast::ItemKind::Const(..) => Target::Const,
+            ast::ItemKind::Fn { .. } => Target::Fn,
+            ast::ItemKind::Mod(..) => Target::Mod,
+            ast::ItemKind::ForeignMod { .. } => Target::ForeignMod,
+            ast::ItemKind::GlobalAsm { .. } => Target::GlobalAsm,
+            ast::ItemKind::TyAlias(..) => Target::TyAlias,
+            ast::ItemKind::Enum(..) => Target::Enum,
+            ast::ItemKind::Struct(..) => Target::Struct,
+            ast::ItemKind::Union(..) => Target::Union,
+            ast::ItemKind::Trait(..) => Target::Trait,
+            ast::ItemKind::TraitAlias(..) => Target::TraitAlias,
+            ast::ItemKind::Impl(ref i) => Target::Impl { of_trait: i.of_trait.is_some() },
+            ast::ItemKind::MacCall(..) => Target::MacroCall,
+            ast::ItemKind::MacroDef(..) => Target::MacroDef,
+            ast::ItemKind::Delegation(..) => Target::Fn,
+            ast::ItemKind::DelegationMac(..) => panic!("macros should be expanded"),
+        }
+    }
+
+    pub fn from_foreign_item_kind(kind: &ast::ForeignItemKind) -> Target {
+        match kind {
+            ForeignItemKind::Static(_) => Target::ForeignStatic,
+            ForeignItemKind::Fn(_) => Target::ForeignFn,
+            ForeignItemKind::TyAlias(_) => Target::ForeignTy,
+            ForeignItemKind::MacCall(_) => panic!("macros should be expanded"),
+        }
+    }
+
     pub fn from_trait_item(trait_item: &TraitItem<'_>) -> Target {
         match trait_item.kind {
             TraitItemKind::Const(..) => Target::AssocConst,
@@ -183,50 +232,132 @@ impl Target {
         }
     }
 
-    pub fn name(self) -> &'static str {
+    pub fn from_assoc_item_kind(kind: &ast::AssocItemKind, assoc_ctxt: AssocCtxt) -> Target {
+        match kind {
+            AssocItemKind::Const(_) => Target::AssocConst,
+            AssocItemKind::Fn(f) => Target::Method(match assoc_ctxt {
+                AssocCtxt::Trait => MethodKind::Trait { body: f.body.is_some() },
+                AssocCtxt::Impl { of_trait } => {
+                    if of_trait {
+                        MethodKind::TraitImpl
+                    } else {
+                        MethodKind::Inherent
+                    }
+                }
+            }),
+            AssocItemKind::Type(_) => Target::AssocTy,
+            AssocItemKind::Delegation(_) => Target::Delegation,
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn from_expr(expr: &ast::Expr) -> Self {
+        match &expr.kind {
+            ast::ExprKind::Closure(..) | ast::ExprKind::Gen(..) => Self::Closure,
+            ast::ExprKind::Paren(e) => Self::from_expr(&e),
+            _ => Self::Expression,
+        }
+    }
+
+    pub fn singular_name(self) -> &'static str {
+        match self {
+            Target::ExternCrate => "an extern crate",
+            Target::Use => "a use statement",
+            Target::Static => "a static",
+            Target::Const => "a constant",
+            Target::Fn => "a function",
+            Target::Closure => "a closure",
+            Target::Mod => "a module",
+            Target::ForeignMod => "a foreign module",
+            Target::GlobalAsm => "a global asm",
+            Target::TyAlias => "a type alias",
+            Target::Enum => "an enum",
+            Target::Variant => "an enum variant",
+            Target::Struct => "a struct",
+            Target::Field => "a struct field",
+            Target::Union => "a union",
+            Target::Trait => "a trait",
+            Target::TraitAlias => "a trait alias",
+            Target::Impl { of_trait: false } => "an inherent impl block",
+            Target::Impl { of_trait: true } => "a trait impl block",
+            Target::Expression => "an expression",
+            Target::Statement => "a statement",
+            Target::Arm => "a match arm",
+            Target::AssocConst => "an associated const",
+            Target::Method(kind) => match kind {
+                MethodKind::Inherent => "an inherent method",
+                MethodKind::Trait { body: false } => "a required trait method",
+                MethodKind::Trait { body: true } => "a provided trait method",
+                MethodKind::TraitImpl => "a trait method in an impl block",
+            },
+            Target::AssocTy => "an associated type",
+            Target::ForeignFn => "a foreign function",
+            Target::ForeignStatic => "a foreign static",
+            Target::ForeignTy => "a foreign type",
+            Target::GenericParam { kind, has_default: _ } => match kind {
+                GenericParamKind::Type => "a type parameter",
+                GenericParamKind::Lifetime => "a lifetime parameter",
+                GenericParamKind::Const => "a const parameter",
+            },
+            Target::MacroDef => "a macro def",
+            Target::Param => "a function param",
+            Target::PatField => "a pattern field",
+            Target::ExprField => "a struct field",
+            Target::WherePredicate => "a where predicate",
+            Target::MacroCall => "a macro call",
+            Target::Crate => "a crate",
+            Target::Delegation => "a delegation",
+        }
+    }
+
+    pub fn plural_name(self) -> &'static str {
         match self {
-            Target::ExternCrate => "extern crate",
-            Target::Use => "use",
-            Target::Static => "static item",
-            Target::Const => "constant item",
-            Target::Fn => "function",
-            Target::Closure => "closure",
-            Target::Mod => "module",
-            Target::ForeignMod => "foreign module",
-            Target::GlobalAsm => "global asm",
-            Target::TyAlias => "type alias",
-            Target::Enum => "enum",
-            Target::Variant => "enum variant",
-            Target::Struct => "struct",
-            Target::Field => "struct field",
-            Target::Union => "union",
-            Target::Trait => "trait",
-            Target::TraitAlias => "trait alias",
-            Target::Impl { of_trait: false } => "inherent implementation block",
-            Target::Impl { of_trait: true } => "trait implementation block",
-            Target::Expression => "expression",
-            Target::Statement => "statement",
-            Target::Arm => "match arm",
-            Target::AssocConst => "associated const",
+            Target::ExternCrate => "extern crates",
+            Target::Use => "use statements",
+            Target::Static => "statics",
+            Target::Const => "constants",
+            Target::Fn => "functions",
+            Target::Closure => "closures",
+            Target::Mod => "modules",
+            Target::ForeignMod => "foreign modules",
+            Target::GlobalAsm => "global asms",
+            Target::TyAlias => "type aliases",
+            Target::Enum => "enums",
+            Target::Variant => "enum variants",
+            Target::Struct => "structs",
+            Target::Field => "struct fields",
+            Target::Union => "unions",
+            Target::Trait => "traits",
+            Target::TraitAlias => "trait aliases",
+            Target::Impl { of_trait: false } => "inherent impl blocks",
+            Target::Impl { of_trait: true } => "trait impl blocks",
+            Target::Expression => "expressions",
+            Target::Statement => "statements",
+            Target::Arm => "match arms",
+            Target::AssocConst => "associated consts",
             Target::Method(kind) => match kind {
-                MethodKind::Inherent => "inherent method",
-                MethodKind::Trait { body: false } => "required trait method",
-                MethodKind::Trait { body: true } => "provided trait method",
+                MethodKind::Inherent => "inherent methods",
+                MethodKind::Trait { body: false } => "required trait methods",
+                MethodKind::Trait { body: true } => "provided trait methods",
+                MethodKind::TraitImpl => "trait methods in impl blocks",
             },
-            Target::AssocTy => "associated type",
-            Target::ForeignFn => "foreign function",
-            Target::ForeignStatic => "foreign static item",
-            Target::ForeignTy => "foreign type",
+            Target::AssocTy => "associated types",
+            Target::ForeignFn => "foreign functions",
+            Target::ForeignStatic => "foreign statics",
+            Target::ForeignTy => "foreign types",
             Target::GenericParam { kind, has_default: _ } => match kind {
-                GenericParamKind::Type => "type parameter",
-                GenericParamKind::Lifetime => "lifetime parameter",
-                GenericParamKind::Const => "const parameter",
+                GenericParamKind::Type => "type parameters",
+                GenericParamKind::Lifetime => "lifetime parameters",
+                GenericParamKind::Const => "const parameters",
             },
-            Target::MacroDef => "macro def",
-            Target::Param => "function param",
-            Target::PatField => "pattern field",
-            Target::ExprField => "struct field",
-            Target::WherePredicate => "where predicate",
+            Target::MacroDef => "macro defs",
+            Target::Param => "function params",
+            Target::PatField => "pattern fields",
+            Target::ExprField => "struct fields",
+            Target::WherePredicate => "where predicates",
+            Target::MacroCall => "macro calls",
+            Target::Crate => "crates",
+            Target::Delegation => "delegations",
         }
     }
 }

compiler/rustc_passes/src/lang_items.rs

@@ -226,7 +226,7 @@ impl<'ast, 'tcx> LanguageItemCollector<'ast, 'tcx> {
                     span: attr_span,
                     generics_span: generics.span,
                     name: name.as_str(),
-                    kind: target.name(),
+                    kind: target.singular_name(),
                     num,
                     actual_num,
                     at_least,
@@ -329,7 +329,7 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
                     match &self.parent_item.unwrap().kind {
                         ast::ItemKind::Impl(i) => {
                             if i.of_trait.is_some() {
-                                Target::Method(MethodKind::Trait { body })
+                                Target::Method(MethodKind::TraitImpl)
                             } else {
                                 Target::Method(MethodKind::Inherent)
                             }