[rustc.git] / src / tools / clippy / clippy_lints / src / non_expressive_names.rs

use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
use rustc_ast::ast::{
    self, Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, Item, ItemKind, Local, Pat, PatKind,
};
use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
use rustc_lint::{EarlyContext, EarlyLintPass};
use rustc_middle::lint::in_external_macro;
use rustc_session::{declare_tool_lint, impl_lint_pass};
use rustc_span::source_map::Span;
use rustc_span::sym;
use rustc_span::symbol::{Ident, Symbol};
use std::cmp::Ordering;

declare_clippy_lint! {
    /// ### What it does
    /// Checks for names that are very similar and thus confusing.
    ///
    /// ### Why is this bad?
    /// It's hard to distinguish between names that differ only
    /// by a single character.
    ///
    /// ### Example
    /// ```ignore
    /// let checked_exp = something;
    /// let checked_expr = something_else;
    /// ```
    pub SIMILAR_NAMES,
    pedantic,
    "similarly named items and bindings"
}

declare_clippy_lint! {
    /// ### What it does
    /// Checks for too many variables whose name consists of a
    /// single character.
    ///
    /// ### Why is this bad?
    /// It's hard to memorize what a variable means without a
    /// descriptive name.
    ///
    /// ### Example
    /// ```ignore
    /// let (a, b, c, d, e, f, g) = (...);
    /// ```
    pub MANY_SINGLE_CHAR_NAMES,
    pedantic,
    "too many single character bindings"
}

declare_clippy_lint! {
    /// ### What it does
    /// Checks if you have variables whose name consists of just
    /// underscores and digits.
    ///
    /// ### Why is this bad?
    /// It's hard to memorize what a variable means without a
    /// descriptive name.
    ///
    /// ### Example
    /// ```rust
    /// let _1 = 1;
    /// let ___1 = 1;
    /// let __1___2 = 11;
    /// ```
    pub JUST_UNDERSCORES_AND_DIGITS,
    style,
    "unclear name"
}

#[derive(Copy, Clone)]
pub struct NonExpressiveNames {
    pub single_char_binding_names_threshold: u64,
}

impl_lint_pass!(NonExpressiveNames => [SIMILAR_NAMES, MANY_SINGLE_CHAR_NAMES, JUST_UNDERSCORES_AND_DIGITS]);

struct ExistingName {
    interned: Symbol,
    span: Span,
    len: usize,
    exemptions: &'static [&'static str],
}

struct SimilarNamesLocalVisitor<'a, 'tcx> {
    names: Vec<ExistingName>,
    cx: &'a EarlyContext<'tcx>,
    lint: &'a NonExpressiveNames,

    /// A stack of scopes containing the single-character bindings in each scope.
    single_char_names: Vec<Vec<Ident>>,
}

impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> {
    fn check_single_char_names(&self) {
        let num_single_char_names = self.single_char_names.iter().flatten().count();
        let threshold = self.lint.single_char_binding_names_threshold;
        if num_single_char_names as u64 > threshold {
            let span = self
                .single_char_names
                .iter()
                .flatten()
                .map(|ident| ident.span)
                .collect::<Vec<_>>();
            span_lint(
                self.cx,
                MANY_SINGLE_CHAR_NAMES,
                span,
                &format!(
                    "{} bindings with single-character names in scope",
                    num_single_char_names
                ),
            );
        }
    }
}

// this list contains lists of names that are allowed to be similar
// the assumption is that no name is ever contained in multiple lists.
#[rustfmt::skip]
const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
    &["parsed", "parser"],
    &["lhs", "rhs"],
    &["tx", "rx"],
    &["set", "get"],
    &["args", "arms"],
    &["qpath", "path"],
    &["lit", "lint"],
    &["wparam", "lparam"],
    &["iter", "item"],
];

struct SimilarNamesNameVisitor<'a, 'tcx, 'b>(&'b mut SimilarNamesLocalVisitor<'a, 'tcx>);

impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
    fn visit_pat(&mut self, pat: &'tcx Pat) {
        match pat.kind {
            PatKind::Ident(_, ident, _) => {
                if !pat.span.from_expansion() {
                    self.check_ident(ident);
                }
            },
            PatKind::Struct(_, _, ref fields, _) => {
                for field in fields {
                    if !field.is_shorthand {
                        self.visit_pat(&field.pat);
                    }
                }
            },
            // just go through the first pattern, as either all patterns
            // bind the same bindings or rustc would have errored much earlier
            PatKind::Or(ref pats) => self.visit_pat(&pats[0]),
            _ => walk_pat(self, pat),
        }
    }
}

#[must_use]
fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> {
    for &list in ALLOWED_TO_BE_SIMILAR {
        if allowed_to_be_similar(interned_name, list) {
            return Some(list);
        }
    }
    None
}

#[must_use]
fn allowed_to_be_similar(interned_name: &str, list: &[&str]) -> bool {
    list.iter()
        .any(|&name| interned_name.starts_with(name) || interned_name.ends_with(name))
}

impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
    fn check_short_ident(&mut self, ident: Ident) {
        // Ignore shadowing
        if self
            .0
            .single_char_names
            .iter()
            .flatten()
            .any(|id| id.name == ident.name)
        {
            return;
        }

        if let Some(scope) = &mut self.0.single_char_names.last_mut() {
            scope.push(ident);
        }
    }

    #[allow(clippy::too_many_lines)]
    fn check_ident(&mut self, ident: Ident) {
        let interned_name = ident.name.as_str();
        if interned_name.chars().any(char::is_uppercase) {
            return;
        }
        if interned_name.chars().all(|c| c.is_digit(10) || c == '_') {
            span_lint(
                self.0.cx,
                JUST_UNDERSCORES_AND_DIGITS,
                ident.span,
                "consider choosing a more descriptive name",
            );
            return;
        }
        if interned_name.starts_with('_') {
            // these bindings are typically unused or represent an ignored portion of a destructuring pattern
            return;
        }
        let count = interned_name.chars().count();
        if count < 3 {
            if count == 1 {
                self.check_short_ident(ident);
            }
            return;
        }
        for existing_name in &self.0.names {
            if allowed_to_be_similar(&interned_name, existing_name.exemptions) {
                continue;
            }
            match existing_name.len.cmp(&count) {
                Ordering::Greater => {
                    if existing_name.len - count != 1
                        || levenstein_not_1(&interned_name, &existing_name.interned.as_str())
                    {
                        continue;
                    }
                },
                Ordering::Less => {
                    if count - existing_name.len != 1
                        || levenstein_not_1(&existing_name.interned.as_str(), &interned_name)
                    {
                        continue;
                    }
                },
                Ordering::Equal => {
                    let mut interned_chars = interned_name.chars();
                    let interned_str = existing_name.interned.as_str();
                    let mut existing_chars = interned_str.chars();
                    let first_i = interned_chars.next().expect("we know we have at least one char");
                    let first_e = existing_chars.next().expect("we know we have at least one char");
                    let eq_or_numeric = |(a, b): (char, char)| a == b || a.is_numeric() && b.is_numeric();

                    if eq_or_numeric((first_i, first_e)) {
                        let last_i = interned_chars.next_back().expect("we know we have at least two chars");
                        let last_e = existing_chars.next_back().expect("we know we have at least two chars");
                        if eq_or_numeric((last_i, last_e)) {
                            if interned_chars
                                .zip(existing_chars)
                                .filter(|&ie| !eq_or_numeric(ie))
                                .count()
                                != 1
                            {
                                continue;
                            }
                        } else {
                            let second_last_i = interned_chars
                                .next_back()
                                .expect("we know we have at least three chars");
                            let second_last_e = existing_chars
                                .next_back()
                                .expect("we know we have at least three chars");
                            if !eq_or_numeric((second_last_i, second_last_e))
                                || second_last_i == '_'
                                || !interned_chars.zip(existing_chars).all(eq_or_numeric)
                            {
                                // allowed similarity foo_x, foo_y
                                // or too many chars differ (foo_x, boo_y) or (foox, booy)
                                continue;
                            }
                        }
                    } else {
                        let second_i = interned_chars.next().expect("we know we have at least two chars");
                        let second_e = existing_chars.next().expect("we know we have at least two chars");
                        if !eq_or_numeric((second_i, second_e))
                            || second_i == '_'
                            || !interned_chars.zip(existing_chars).all(eq_or_numeric)
                        {
                            // allowed similarity x_foo, y_foo
                            // or too many chars differ (x_foo, y_boo) or (xfoo, yboo)
                            continue;
                        }
                    }
                },
            }
            span_lint_and_then(
                self.0.cx,
                SIMILAR_NAMES,
                ident.span,
                "binding's name is too similar to existing binding",
                |diag| {
                    diag.span_note(existing_name.span, "existing binding defined here");
                },
            );
            return;
        }
        self.0.names.push(ExistingName {
            exemptions: get_exemptions(&interned_name).unwrap_or(&[]),
            interned: ident.name,
            span: ident.span,
            len: count,
        });
    }
}

impl<'a, 'b> SimilarNamesLocalVisitor<'a, 'b> {
    /// ensure scoping rules work
    fn apply<F: for<'c> Fn(&'c mut Self)>(&mut self, f: F) {
        let n = self.names.len();
        let single_char_count = self.single_char_names.len();
        f(self);
        self.names.truncate(n);
        self.single_char_names.truncate(single_char_count);
    }
}

impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
    fn visit_local(&mut self, local: &'tcx Local) {
        if let Some((init, els)) = &local.kind.init_else_opt() {
            self.apply(|this| walk_expr(this, init));
            if let Some(els) = els {
                self.apply(|this| walk_block(this, els));
            }
        }
        // add the pattern after the expression because the bindings aren't available
        // yet in the init
        // expression
        SimilarNamesNameVisitor(self).visit_pat(&*local.pat);
    }
    fn visit_block(&mut self, blk: &'tcx Block) {
        self.single_char_names.push(vec![]);

        self.apply(|this| walk_block(this, blk));

        self.check_single_char_names();
        self.single_char_names.pop();
    }
    fn visit_arm(&mut self, arm: &'tcx Arm) {
        self.single_char_names.push(vec![]);

        self.apply(|this| {
            SimilarNamesNameVisitor(this).visit_pat(&arm.pat);
            this.apply(|this| walk_expr(this, &arm.body));
        });

        self.check_single_char_names();
        self.single_char_names.pop();
    }
    fn visit_item(&mut self, _: &Item) {
        // do not recurse into inner items
    }
}

impl EarlyLintPass for NonExpressiveNames {
    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
        if in_external_macro(cx.sess, item.span) {
            return;
        }

        if let ItemKind::Fn(box ast::Fn { ref sig, body: Some(ref blk), .. }) = item.kind {
            do_check(self, cx, &item.attrs, &sig.decl, blk);
        }
    }

    fn check_impl_item(&mut self, cx: &EarlyContext<'_>, item: &AssocItem) {
        if in_external_macro(cx.sess, item.span) {
            return;
        }

        if let AssocItemKind::Fn(box ast::Fn { ref sig, body: Some(ref blk), .. }) = item.kind {
            do_check(self, cx, &item.attrs, &sig.decl, blk);
        }
    }
}

fn do_check(lint: &mut NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attribute], decl: &FnDecl, blk: &Block) {
    if !attrs.iter().any(|attr| attr.has_name(sym::test)) {
        let mut visitor = SimilarNamesLocalVisitor {
            names: Vec::new(),
            cx,
            lint,
            single_char_names: vec![vec![]],
        };

        // initialize with function arguments
        for arg in &decl.inputs {
            SimilarNamesNameVisitor(&mut visitor).visit_pat(&arg.pat);
        }
        // walk all other bindings
        walk_block(&mut visitor, blk);

        visitor.check_single_char_names();
    }
}

/// Precondition: `a_name.chars().count() < b_name.chars().count()`.
#[must_use]
fn levenstein_not_1(a_name: &str, b_name: &str) -> bool {
    debug_assert!(a_name.chars().count() < b_name.chars().count());
    let mut a_chars = a_name.chars();
    let mut b_chars = b_name.chars();
    while let (Some(a), Some(b)) = (a_chars.next(), b_chars.next()) {
        if a == b {
            continue;
        }
        if let Some(b2) = b_chars.next() {
            // check if there's just one character inserted
            return a != b2 || a_chars.ne(b_chars);
        }
        // tuple
        // ntuple
        return true;
    }
    // for item in items
    true
}
Commit	Line	Data
cdc7bbd5	1	use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
f20569fa	2	use rustc_ast::ast::{
3c0e092e	3	self, Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, Item, ItemKind, Local, Pat, PatKind,
f20569fa XL	4	};
	5	use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
	6	use rustc_lint::{EarlyContext, EarlyLintPass};
	7	use rustc_middle::lint::in_external_macro;
	8	use rustc_session::{declare_tool_lint, impl_lint_pass};
	9	use rustc_span::source_map::Span;
	10	use rustc_span::sym;
	11	use rustc_span::symbol::{Ident, Symbol};
	12	use std::cmp::Ordering;
	13
	14	declare_clippy_lint! {
94222f64 XL	15	/// ### What it does
94222f64 XL	16	/// Checks for names that are very similar and thus confusing.
f20569fa	17	///
94222f64 XL	18	/// ### Why is this bad?
94222f64 XL	19	/// It's hard to distinguish between names that differ only
f20569fa XL	20	/// by a single character.
f20569fa XL	21	///
94222f64	22	/// ### Example
f20569fa XL	23	/// ```ignore
	24	/// let checked_exp = something;
	25	/// let checked_expr = something_else;
	26	/// ```
	27	pub SIMILAR_NAMES,
	28	pedantic,
	29	"similarly named items and bindings"
	30	}
	31
	32	declare_clippy_lint! {
94222f64 XL	33	/// ### What it does
94222f64 XL	34	/// Checks for too many variables whose name consists of a
f20569fa XL	35	/// single character.
f20569fa XL	36	///
94222f64 XL	37	/// ### Why is this bad?
94222f64 XL	38	/// It's hard to memorize what a variable means without a
f20569fa XL	39	/// descriptive name.
f20569fa XL	40	///
94222f64	41	/// ### Example
f20569fa XL	42	/// ```ignore
	43	/// let (a, b, c, d, e, f, g) = (...);
	44	/// ```
	45	pub MANY_SINGLE_CHAR_NAMES,
c295e0f8	46	pedantic,
f20569fa XL	47	"too many single character bindings"
	48	}
	49
	50	declare_clippy_lint! {
94222f64 XL	51	/// ### What it does
94222f64 XL	52	/// Checks if you have variables whose name consists of just
f20569fa XL	53	/// underscores and digits.
f20569fa XL	54	///
94222f64 XL	55	/// ### Why is this bad?
94222f64 XL	56	/// It's hard to memorize what a variable means without a
f20569fa XL	57	/// descriptive name.
f20569fa XL	58	///
94222f64	59	/// ### Example
f20569fa XL	60	/// ```rust
	61	/// let _1 = 1;
	62	/// let ___1 = 1;
	63	/// let __1___2 = 11;
	64	/// ```
	65	pub JUST_UNDERSCORES_AND_DIGITS,
	66	style,
	67	"unclear name"
	68	}
	69
	70	#[derive(Copy, Clone)]
	71	pub struct NonExpressiveNames {
	72	pub single_char_binding_names_threshold: u64,
	73	}
	74
	75	impl_lint_pass!(NonExpressiveNames => [SIMILAR_NAMES, MANY_SINGLE_CHAR_NAMES, JUST_UNDERSCORES_AND_DIGITS]);
	76
	77	struct ExistingName {
	78	interned: Symbol,
	79	span: Span,
	80	len: usize,
	81	exemptions: &'static [&'static str],
	82	}
	83
	84	struct SimilarNamesLocalVisitor<'a, 'tcx> {
	85	names: Vec<ExistingName>,
	86	cx: &'a EarlyContext<'tcx>,
	87	lint: &'a NonExpressiveNames,
	88
	89	/// A stack of scopes containing the single-character bindings in each scope.
	90	single_char_names: Vec<Vec<Ident>>,
	91	}
	92
	93	impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> {
	94	fn check_single_char_names(&self) {
	95	let num_single_char_names = self.single_char_names.iter().flatten().count();
	96	let threshold = self.lint.single_char_binding_names_threshold;
	97	if num_single_char_names as u64 > threshold {
	98	let span = self
	99	.single_char_names
	100	.iter()
	101	.flatten()
	102	.map(\|ident\| ident.span)
	103	.collect::<Vec<_>>();
	104	span_lint(
	105	self.cx,
	106	MANY_SINGLE_CHAR_NAMES,
	107	span,
	108	&format!(
	109	"{} bindings with single-character names in scope",
	110	num_single_char_names
	111	),
	112	);
	113	}
	114	}
	115	}
	116
	117	// this list contains lists of names that are allowed to be similar
	118	// the assumption is that no name is ever contained in multiple lists.
	119	#[rustfmt::skip]
	120	const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
	121	&["parsed", "parser"],
	122	&["lhs", "rhs"],
	123	&["tx", "rx"],
124	&["set", "get"],
125	&["args", "arms"],
126	&["qpath", "path"],
127	&["lit", "lint"],
17df50a5	128	&["wparam", "lparam"],
94222f64	129	&["iter", "item"],
f20569fa XL	130	];
	131
	132	struct SimilarNamesNameVisitor<'a, 'tcx, 'b>(&'b mut SimilarNamesLocalVisitor<'a, 'tcx>);
	133
	134	impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
	135	fn visit_pat(&mut self, pat: &'tcx Pat) {
	136	match pat.kind {
	137	PatKind::Ident(_, ident, _) => {
	138	if !pat.span.from_expansion() {
	139	self.check_ident(ident);
	140	}
	141	},
17df50a5	142	PatKind::Struct(_, _, ref fields, _) => {
f20569fa XL	143	for field in fields {
	144	if !field.is_shorthand {
	145	self.visit_pat(&field.pat);
	146	}
	147	}
	148	},
	149	// just go through the first pattern, as either all patterns
	150	// bind the same bindings or rustc would have errored much earlier
	151	PatKind::Or(ref pats) => self.visit_pat(&pats[0]),
	152	_ => walk_pat(self, pat),
	153	}
	154	}
	155	}
	156
	157	#[must_use]
	158	fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> {
	159	for &list in ALLOWED_TO_BE_SIMILAR {
	160	if allowed_to_be_similar(interned_name, list) {
	161	return Some(list);
	162	}
	163	}
	164	None
	165	}
	166
	167	#[must_use]
	168	fn allowed_to_be_similar(interned_name: &str, list: &[&str]) -> bool {
	169	list.iter()
	170	.any(\|&name\| interned_name.starts_with(name) \|\| interned_name.ends_with(name))
	171	}
	172
	173	impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
	174	fn check_short_ident(&mut self, ident: Ident) {
	175	// Ignore shadowing
	176	if self
	177	.0
	178	.single_char_names
	179	.iter()
	180	.flatten()
	181	.any(\|id\| id.name == ident.name)
	182	{
	183	return;
	184	}
	185
	186	if let Some(scope) = &mut self.0.single_char_names.last_mut() {
	187	scope.push(ident);
	188	}
	189	}
	190
	191	#[allow(clippy::too_many_lines)]
	192	fn check_ident(&mut self, ident: Ident) {
	193	let interned_name = ident.name.as_str();
	194	if interned_name.chars().any(char::is_uppercase) {
	195	return;
	196	}
	197	if interned_name.chars().all(\|c\| c.is_digit(10) \|\| c == '_') {
	198	span_lint(
	199	self.0.cx,
	200	JUST_UNDERSCORES_AND_DIGITS,
	201	ident.span,
	202	"consider choosing a more descriptive name",
	203	);
	204	return;
	205	}
	206	if interned_name.starts_with('_') {
207	// these bindings are typically unused or represent an ignored portion of a destructuring pattern
208	return;
209	}
210	let count = interned_name.chars().count();
211	if count < 3 {
212	if count == 1 {
213	self.check_short_ident(ident);
214	}
215	return;
216	}
217	for existing_name in &self.0.names {
218	if allowed_to_be_similar(&interned_name, existing_name.exemptions) {
219	continue;
220	}
f20569fa XL	221	match existing_name.len.cmp(&count) {
	222	Ordering::Greater => {
	223	if existing_name.len - count != 1
	224	\|\| levenstein_not_1(&interned_name, &existing_name.interned.as_str())
	225	{
	226	continue;
	227	}
	228	},
	229	Ordering::Less => {
	230	if count - existing_name.len != 1
	231	\|\| levenstein_not_1(&existing_name.interned.as_str(), &interned_name)
	232	{
	233	continue;
	234	}
	235	},
	236	Ordering::Equal => {
	237	let mut interned_chars = interned_name.chars();
	238	let interned_str = existing_name.interned.as_str();
	239	let mut existing_chars = interned_str.chars();
	240	let first_i = interned_chars.next().expect("we know we have at least one char");
	241	let first_e = existing_chars.next().expect("we know we have at least one char");
	242	let eq_or_numeric = \|(a, b): (char, char)\| a == b \|\| a.is_numeric() && b.is_numeric();
	243
	244	if eq_or_numeric((first_i, first_e)) {
	245	let last_i = interned_chars.next_back().expect("we know we have at least two chars");
	246	let last_e = existing_chars.next_back().expect("we know we have at least two chars");
	247	if eq_or_numeric((last_i, last_e)) {
	248	if interned_chars
	249	.zip(existing_chars)
	250	.filter(\|&ie\| !eq_or_numeric(ie))
	251	.count()
	252	!= 1
	253	{
	254	continue;
	255	}
	256	} else {
	257	let second_last_i = interned_chars
	258	.next_back()
	259	.expect("we know we have at least three chars");
	260	let second_last_e = existing_chars
	261	.next_back()
	262	.expect("we know we have at least three chars");
	263	if !eq_or_numeric((second_last_i, second_last_e))
	264	\|\| second_last_i == '_'
	265	\|\| !interned_chars.zip(existing_chars).all(eq_or_numeric)
	266	{
	267	// allowed similarity foo_x, foo_y
	268	// or too many chars differ (foo_x, boo_y) or (foox, booy)
	269	continue;
	270	}
f20569fa XL	271	}
	272	} else {
	273	let second_i = interned_chars.next().expect("we know we have at least two chars");
	274	let second_e = existing_chars.next().expect("we know we have at least two chars");
	275	if !eq_or_numeric((second_i, second_e))
	276	\|\| second_i == '_'
	277	\|\| !interned_chars.zip(existing_chars).all(eq_or_numeric)
	278	{
	279	// allowed similarity x_foo, y_foo
	280	// or too many chars differ (x_foo, y_boo) or (xfoo, yboo)
	281	continue;
	282	}
f20569fa XL	283	}
	284	},
	285	}
	286	span_lint_and_then(
	287	self.0.cx,
	288	SIMILAR_NAMES,
	289	ident.span,
	290	"binding's name is too similar to existing binding",
	291	\|diag\| {
	292	diag.span_note(existing_name.span, "existing binding defined here");
f20569fa XL	293	},
	294	);
	295	return;
	296	}
	297	self.0.names.push(ExistingName {
	298	exemptions: get_exemptions(&interned_name).unwrap_or(&[]),
	299	interned: ident.name,
	300	span: ident.span,
	301	len: count,
	302	});
	303	}
	304	}
	305
	306	impl<'a, 'b> SimilarNamesLocalVisitor<'a, 'b> {
	307	/// ensure scoping rules work
	308	fn apply<F: for<'c> Fn(&'c mut Self)>(&mut self, f: F) {
	309	let n = self.names.len();
	310	let single_char_count = self.single_char_names.len();
	311	f(self);
	312	self.names.truncate(n);
	313	self.single_char_names.truncate(single_char_count);
	314	}
	315	}
	316
	317	impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
	318	fn visit_local(&mut self, local: &'tcx Local) {
94222f64 XL	319	if let Some((init, els)) = &local.kind.init_else_opt() {
	320	self.apply(\|this\| walk_expr(this, init));
	321	if let Some(els) = els {
	322	self.apply(\|this\| walk_block(this, els));
	323	}
f20569fa XL	324	}
	325	// add the pattern after the expression because the bindings aren't available
	326	// yet in the init
	327	// expression
	328	SimilarNamesNameVisitor(self).visit_pat(&*local.pat);
	329	}
	330	fn visit_block(&mut self, blk: &'tcx Block) {
	331	self.single_char_names.push(vec![]);
	332
	333	self.apply(\|this\| walk_block(this, blk));
	334
	335	self.check_single_char_names();
	336	self.single_char_names.pop();
	337	}
	338	fn visit_arm(&mut self, arm: &'tcx Arm) {
	339	self.single_char_names.push(vec![]);
	340
	341	self.apply(\|this\| {
	342	SimilarNamesNameVisitor(this).visit_pat(&arm.pat);
	343	this.apply(\|this\| walk_expr(this, &arm.body));
	344	});
	345
	346	self.check_single_char_names();
	347	self.single_char_names.pop();
	348	}
	349	fn visit_item(&mut self, _: &Item) {
	350	// do not recurse into inner items
	351	}
	352	}
	353
	354	impl EarlyLintPass for NonExpressiveNames {
	355	fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
	356	if in_external_macro(cx.sess, item.span) {
	357	return;
	358	}
	359
3c0e092e	360	if let ItemKind::Fn(box ast::Fn { ref sig, body: Some(ref blk), .. }) = item.kind {
f20569fa XL	361	do_check(self, cx, &item.attrs, &sig.decl, blk);
	362	}
	363	}
	364
	365	fn check_impl_item(&mut self, cx: &EarlyContext<'_>, item: &AssocItem) {
	366	if in_external_macro(cx.sess, item.span) {
	367	return;
	368	}
	369
3c0e092e	370	if let AssocItemKind::Fn(box ast::Fn { ref sig, body: Some(ref blk), .. }) = item.kind {
f20569fa XL	371	do_check(self, cx, &item.attrs, &sig.decl, blk);
	372	}
	373	}
	374	}
	375
	376	fn do_check(lint: &mut NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attribute], decl: &FnDecl, blk: &Block) {
	377	if !attrs.iter().any(\|attr\| attr.has_name(sym::test)) {
	378	let mut visitor = SimilarNamesLocalVisitor {
	379	names: Vec::new(),
	380	cx,
	381	lint,
	382	single_char_names: vec![vec![]],
	383	};
	384
	385	// initialize with function arguments
	386	for arg in &decl.inputs {
	387	SimilarNamesNameVisitor(&mut visitor).visit_pat(&arg.pat);
	388	}
	389	// walk all other bindings
	390	walk_block(&mut visitor, blk);
	391
	392	visitor.check_single_char_names();
	393	}
	394	}
	395
	396	/// Precondition: `a_name.chars().count() < b_name.chars().count()`.
	397	#[must_use]
	398	fn levenstein_not_1(a_name: &str, b_name: &str) -> bool {
	399	debug_assert!(a_name.chars().count() < b_name.chars().count());
	400	let mut a_chars = a_name.chars();
	401	let mut b_chars = b_name.chars();
	402	while let (Some(a), Some(b)) = (a_chars.next(), b_chars.next()) {
	403	if a == b {
	404	continue;
	405	}
	406	if let Some(b2) = b_chars.next() {
	407	// check if there's just one character inserted
	408	return a != b2 \|\| a_chars.ne(b_chars);
	409	}
	410	// tuple
	411	// ntuple
	412	return true;
	413	}
	414	// for item in items
	415	true
	416	}