clippy_lints/src/enum_variants.rs

   1 //! lint on enum variants that are prefixed or suffixed by the same characters
   2
   3 use crate::utils::{camel_case, in_macro, is_present_in_source};
   4 use crate::utils::{span_help_and_lint, span_lint};
   5 use rustc::lint::{EarlyContext, EarlyLintPass, Lint, LintArray, LintPass};
   6 use rustc::{declare_tool_lint, impl_lint_pass};
   7 use syntax::ast::*;
   8 use syntax::source_map::Span;
   9 use syntax::symbol::{InternedString, LocalInternedString};
  10
  11 declare_clippy_lint! {
  12     /// **What it does:** Detects enumeration variants that are prefixed or suffixed
  13     /// by the same characters.
  14     ///
  15     /// **Why is this bad?** Enumeration variant names should specify their variant,
  16     /// not repeat the enumeration name.
  17     ///
  18     /// **Known problems:** None.
  19     ///
  20     /// **Example:**
  21     /// ```rust
  22     /// enum Cake {
  23     ///     BlackForestCake,
  24     ///     HummingbirdCake,
  25     ///     BattenbergCake,
  26     /// }
  27     /// ```
  28     pub ENUM_VARIANT_NAMES,
  29     style,
  30     "enums where all variants share a prefix/postfix"
  31 }
  32
  33 declare_clippy_lint! {
  34     /// **What it does:** Detects enumeration variants that are prefixed or suffixed
  35     /// by the same characters.
  36     ///
  37     /// **Why is this bad?** Enumeration variant names should specify their variant,
  38     /// not repeat the enumeration name.
  39     ///
  40     /// **Known problems:** None.
  41     ///
  42     /// **Example:**
  43     /// ```rust
  44     /// enum Cake {
  45     ///     BlackForestCake,
  46     ///     HummingbirdCake,
  47     ///     BattenbergCake,
  48     /// }
  49     /// ```
  50     pub PUB_ENUM_VARIANT_NAMES,
  51     pedantic,
  52     "enums where all variants share a prefix/postfix"
  53 }
  54
  55 declare_clippy_lint! {
  56     /// **What it does:** Detects type names that are prefixed or suffixed by the
  57     /// containing module's name.
  58     ///
  59     /// **Why is this bad?** It requires the user to type the module name twice.
  60     ///
  61     /// **Known problems:** None.
  62     ///
  63     /// **Example:**
  64     /// ```rust
  65     /// mod cake {
  66     ///     struct BlackForestCake;
  67     /// }
  68     /// ```
  69     pub MODULE_NAME_REPETITIONS,
  70     pedantic,
  71     "type names prefixed/postfixed with their containing module's name"
  72 }
  73
  74 declare_clippy_lint! {
  75     /// **What it does:** Checks for modules that have the same name as their
  76     /// parent module
  77     ///
  78     /// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and
  79     /// again `mod foo { ..
  80     /// }` in `foo.rs`.
  81     /// The expectation is that items inside the inner `mod foo { .. }` are then
  82     /// available
  83     /// through `foo::x`, but they are only available through
  84     /// `foo::foo::x`.
  85     /// If this is done on purpose, it would be better to choose a more
  86     /// representative module name.
  87     ///
  88     /// **Known problems:** None.
  89     ///
  90     /// **Example:**
  91     /// ```ignore
  92     /// // lib.rs
  93     /// mod foo;
  94     /// // foo.rs
  95     /// mod foo {
  96     ///     ...
  97     /// }
  98     /// ```
  99     pub MODULE_INCEPTION,
 100     style,
 101     "modules that have the same name as their parent module"
 102 }
 103
 104 pub struct EnumVariantNames {
 105     modules: Vec<(InternedString, String)>,
 106     threshold: u64,
 107 }
 108
 109 impl EnumVariantNames {
 110     pub fn new(threshold: u64) -> Self {
 111         Self {
 112             modules: Vec::new(),
 113             threshold,
 114         }
 115     }
 116 }
 117
 118 impl_lint_pass!(EnumVariantNames => [
 119     ENUM_VARIANT_NAMES,
 120     PUB_ENUM_VARIANT_NAMES,
 121     MODULE_NAME_REPETITIONS,
 122     MODULE_INCEPTION
 123 ]);
 124
 125 fn var2str(var: &Variant) -> LocalInternedString {
 126     var.node.ident.as_str()
 127 }
 128
 129 /// Returns the number of chars that match from the start
 130 fn partial_match(pre: &str, name: &str) -> usize {
 131     let mut name_iter = name.chars();
 132     let _ = name_iter.next_back(); // make sure the name is never fully matched
 133     pre.chars().zip(name_iter).take_while(|&(l, r)| l == r).count()
 134 }
 135
 136 /// Returns the number of chars that match from the end
 137 fn partial_rmatch(post: &str, name: &str) -> usize {
 138     let mut name_iter = name.chars();
 139     let _ = name_iter.next(); // make sure the name is never fully matched
 140     post.chars()
 141         .rev()
 142         .zip(name_iter.rev())
 143         .take_while(|&(l, r)| l == r)
 144         .count()
 145 }
 146
 147 fn check_variant(
 148     cx: &EarlyContext<'_>,
 149     threshold: u64,
 150     def: &EnumDef,
 151     item_name: &str,
 152     item_name_chars: usize,
 153     span: Span,
 154     lint: &'static Lint,
 155 ) {
 156     if (def.variants.len() as u64) < threshold {
 157         return;
 158     }
 159     for var in &def.variants {
 160         let name = var2str(var);
 161         if partial_match(item_name, &name) == item_name_chars
 162             && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
 163         {
 164             span_lint(cx, lint, var.span, "Variant name starts with the enum's name");
 165         }
 166         if partial_rmatch(item_name, &name) == item_name_chars {
 167             span_lint(cx, lint, var.span, "Variant name ends with the enum's name");
 168         }
 169     }
 170     let first = var2str(&def.variants[0]);
 171     let mut pre = &first[..camel_case::until(&*first)];
 172     let mut post = &first[camel_case::from(&*first)..];
 173     for var in &def.variants {
 174         let name = var2str(var);
 175
 176         let pre_match = partial_match(pre, &name);
 177         pre = &pre[..pre_match];
 178         let pre_camel = camel_case::until(pre);
 179         pre = &pre[..pre_camel];
 180         while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
 181             if next.is_lowercase() {
 182                 let last = pre.len() - last.len_utf8();
 183                 let last_camel = camel_case::until(&pre[..last]);
 184                 pre = &pre[..last_camel];
 185             } else {
 186                 break;
 187             }
 188         }
 189
 190         let post_match = partial_rmatch(post, &name);
 191         let post_end = post.len() - post_match;
 192         post = &post[post_end..];
 193         let post_camel = camel_case::from(post);
 194         post = &post[post_camel..];
 195     }
 196     let (what, value) = match (pre.is_empty(), post.is_empty()) {
 197         (true, true) => return,
 198         (false, _) => ("pre", pre),
 199         (true, false) => ("post", post),
 200     };
 201     span_help_and_lint(
 202         cx,
 203         lint,
 204         span,
 205         &format!("All variants have the same {}fix: `{}`", what, value),
 206         &format!(
 207             "remove the {}fixes and use full paths to \
 208              the variants instead of glob imports",
 209             what
 210         ),
 211     );
 212 }
 213
 214 fn to_camel_case(item_name: &str) -> String {
 215     let mut s = String::new();
 216     let mut up = true;
 217     for c in item_name.chars() {
 218         if c.is_uppercase() {
 219             // we only turn snake case text into CamelCase
 220             return item_name.to_string();
 221         }
 222         if c == '_' {
 223             up = true;
 224             continue;
 225         }
 226         if up {
 227             up = false;
 228             s.extend(c.to_uppercase());
 229         } else {
 230             s.push(c);
 231         }
 232     }
 233     s
 234 }
 235
 236 impl EarlyLintPass for EnumVariantNames {
 237     fn check_item_post(&mut self, _cx: &EarlyContext<'_>, _item: &Item) {
 238         let last = self.modules.pop();
 239         assert!(last.is_some());
 240     }
 241
 242     #[allow(clippy::similar_names)]
 243     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
 244         let item_name = item.ident.as_str();
 245         let item_name_chars = item_name.chars().count();
 246         let item_camel = to_camel_case(&item_name);
 247         if !in_macro(item.span) && is_present_in_source(cx, item.span) {
 248             if let Some(&(ref mod_name, ref mod_camel)) = self.modules.last() {
 249                 // constants don't have surrounding modules
 250                 if !mod_camel.is_empty() {
 251                     if *mod_name == item_name {
 252                         if let ItemKind::Mod(..) = item.node {
 253                             span_lint(
 254                                 cx,
 255                                 MODULE_INCEPTION,
 256                                 item.span,
 257                                 "module has the same name as its containing module",
 258                             );
 259                         }
 260                     }
 261                     if item.vis.node.is_pub() {
 262                         let matching = partial_match(mod_camel, &item_camel);
 263                         let rmatching = partial_rmatch(mod_camel, &item_camel);
 264                         let nchars = mod_camel.chars().count();
 265
 266                         let is_word_beginning = |c: char| c == '_' || c.is_uppercase() || c.is_numeric();
 267
 268                         if matching == nchars {
 269                             match item_camel.chars().nth(nchars) {
 270                                 Some(c) if is_word_beginning(c) => span_lint(
 271                                     cx,
 272                                     MODULE_NAME_REPETITIONS,
 273                                     item.span,
 274                                     "item name starts with its containing module's name",
 275                                 ),
 276                                 _ => (),
 277                             }
 278                         }
 279                         if rmatching == nchars {
 280                             span_lint(
 281                                 cx,
 282                                 MODULE_NAME_REPETITIONS,
 283                                 item.span,
 284                                 "item name ends with its containing module's name",
 285                             );
 286                         }
 287                     }
 288                 }
 289             }
 290         }
 291         if let ItemKind::Enum(ref def, _) = item.node {
 292             let lint = match item.vis.node {
 293                 VisibilityKind::Public => PUB_ENUM_VARIANT_NAMES,
 294                 _ => ENUM_VARIANT_NAMES,
 295             };
 296             check_variant(cx, self.threshold, def, &item_name, item_name_chars, item.span, lint);
 297         }
 298         self.modules.push((item_name.as_interned_str(), item_camel));
 299     }
 300 }