1 //! lint on enum variants that are prefixed or suffixed by the same characters
3 use clippy_utils::camel_case;
4 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
5 use clippy_utils::source::is_present_in_source;
6 use rustc_hir::{EnumDef, Item, ItemKind};
7 use rustc_lint::{LateContext, LateLintPass};
8 use rustc_session::{declare_tool_lint, impl_lint_pass};
9 use rustc_span::source_map::Span;
10 use rustc_span::symbol::Symbol;
12 declare_clippy_lint! {
14 /// Detects enumeration variants that are prefixed or suffixed
15 /// by the same characters.
17 /// ### Why is this bad?
18 /// Enumeration variant names should specify their variant,
19 /// not repeat the enumeration name.
29 /// Could be written as:
37 pub ENUM_VARIANT_NAMES,
39 "enums where all variants share a prefix/postfix"
42 declare_clippy_lint! {
44 /// Detects type names that are prefixed or suffixed by the
45 /// containing module's name.
47 /// ### Why is this bad?
48 /// It requires the user to type the module name twice.
53 /// struct BlackForestCake;
56 /// Could be written as:
59 /// struct BlackForest;
62 pub MODULE_NAME_REPETITIONS,
64 "type names prefixed/postfixed with their containing module's name"
67 declare_clippy_lint! {
69 /// Checks for modules that have the same name as their
72 /// ### Why is this bad?
73 /// A typical beginner mistake is to have `mod foo;` and
74 /// again `mod foo { ..
76 /// The expectation is that items inside the inner `mod foo { .. }` are then
78 /// through `foo::x`, but they are only available through
80 /// If this is done on purpose, it would be better to choose a more
81 /// representative module name.
94 "modules that have the same name as their parent module"
97 pub struct EnumVariantNames {
98 modules: Vec<(Symbol, String)>,
100 avoid_breaking_exported_api: bool,
103 impl EnumVariantNames {
105 pub fn new(threshold: u64, avoid_breaking_exported_api: bool) -> Self {
109 avoid_breaking_exported_api,
114 impl_lint_pass!(EnumVariantNames => [
116 MODULE_NAME_REPETITIONS,
120 /// Returns the number of chars that match from the start
122 fn partial_match(pre: &str, name: &str) -> usize {
123 let mut name_iter = name.chars();
124 let _ = name_iter.next_back(); // make sure the name is never fully matched
125 pre.chars().zip(name_iter).take_while(|&(l, r)| l == r).count()
128 /// Returns the number of chars that match from the end
130 fn partial_rmatch(post: &str, name: &str) -> usize {
131 let mut name_iter = name.chars();
132 let _ = name_iter.next(); // make sure the name is never fully matched
135 .zip(name_iter.rev())
136 .take_while(|&(l, r)| l == r)
141 cx: &LateContext<'_>,
145 item_name_chars: usize,
148 if (def.variants.len() as u64) < threshold {
151 for var in def.variants {
152 let name = var.ident.name.as_str();
153 if partial_match(item_name, &name) == item_name_chars
154 && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
155 && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
161 "variant name starts with the enum's name",
164 if partial_rmatch(item_name, &name) == item_name_chars {
169 "variant name ends with the enum's name",
173 let first = &def.variants[0].ident.name.as_str();
174 let mut pre = &first[..camel_case::until(&*first)];
175 let mut post = &first[camel_case::from(&*first)..];
176 for var in def.variants {
177 let name = var.ident.name.as_str();
179 let pre_match = partial_match(pre, &name);
180 pre = &pre[..pre_match];
181 let pre_camel = camel_case::until(pre);
182 pre = &pre[..pre_camel];
183 while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
184 if next.is_numeric() {
187 if next.is_lowercase() {
188 let last = pre.len() - last.len_utf8();
189 let last_camel = camel_case::until(&pre[..last]);
190 pre = &pre[..last_camel];
196 let post_match = partial_rmatch(post, &name);
197 let post_end = post.len() - post_match;
198 post = &post[post_end..];
199 let post_camel = camel_case::from(post);
200 post = &post[post_camel..];
202 let (what, value) = match (pre.is_empty(), post.is_empty()) {
203 (true, true) => return,
204 (false, _) => ("pre", pre),
205 (true, false) => ("post", post),
211 &format!("all variants have the same {}fix: `{}`", what, value),
214 "remove the {}fixes and use full paths to \
215 the variants instead of glob imports",
222 fn to_camel_case(item_name: &str) -> String {
223 let mut s = String::new();
225 for c in item_name.chars() {
226 if c.is_uppercase() {
227 // we only turn snake case text into CamelCase
228 return item_name.to_string();
236 s.extend(c.to_uppercase());
244 impl LateLintPass<'_> for EnumVariantNames {
245 fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
246 let last = self.modules.pop();
247 assert!(last.is_some());
250 #[allow(clippy::similar_names)]
251 fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
252 let item_name = item.ident.name.as_str();
253 let item_name_chars = item_name.chars().count();
254 let item_camel = to_camel_case(&item_name);
255 if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
256 if let Some(&(ref mod_name, ref mod_camel)) = self.modules.last() {
257 // constants don't have surrounding modules
258 if !mod_camel.is_empty() {
259 if mod_name == &item.ident.name {
260 if let ItemKind::Mod(..) = item.kind {
265 "module has the same name as its containing module",
269 if item.vis.node.is_pub() {
270 let matching = partial_match(mod_camel, &item_camel);
271 let rmatching = partial_rmatch(mod_camel, &item_camel);
272 let nchars = mod_camel.chars().count();
274 let is_word_beginning = |c: char| c == '_' || c.is_uppercase() || c.is_numeric();
276 if matching == nchars {
277 match item_camel.chars().nth(nchars) {
278 Some(c) if is_word_beginning(c) => span_lint(
280 MODULE_NAME_REPETITIONS,
282 "item name starts with its containing module's name",
287 if rmatching == nchars {
290 MODULE_NAME_REPETITIONS,
292 "item name ends with its containing module's name",
299 if let ItemKind::Enum(ref def, _) = item.kind {
300 if !(self.avoid_breaking_exported_api && cx.access_levels.is_exported(item.hir_id())) {
301 check_variant(cx, self.threshold, def, &item_name, item_name_chars, item.span);
304 self.modules.push((item.ident.name, item_camel));