New internal lint: unusual_names

This lint aims at detecting unusual names used in Clippy source codes,
such as `appl` or `application` for a `rustc_errors::Applicability`
variable, while `app` and `applicability` are commonly used throughout
Clippy.

This helps maintaining consistency.

Author: samueltardieu

clippy_lints_internal/src/internal_paths.rs

@@ -2,6 +2,7 @@ use clippy_utils::paths::{PathLookup, PathNS};
 use clippy_utils::{sym, type_path, value_path};
 
 // Paths inside rustc
+pub static APPLICABILITY: PathLookup = type_path!(rustc_errors::Applicability);
 pub static EARLY_LINT_PASS: PathLookup = type_path!(rustc_lint::passes::EarlyLintPass);
 pub static KW_MODULE: PathLookup = type_path!(rustc_span::symbol::kw);
 pub static LINT: PathLookup = type_path!(rustc_lint_defs::Lint);

clippy_lints_internal/src/lib.rs

@@ -41,6 +41,7 @@ mod produce_ice;
 mod symbols;
 mod unnecessary_def_path;
 mod unsorted_clippy_utils_paths;
+mod unusual_names;
 
 use rustc_lint::{Lint, LintStore};
 
@@ -59,6 +60,7 @@ static LINTS: &[&Lint] = &[
     symbols::SYMBOL_AS_STR,
     unnecessary_def_path::UNNECESSARY_DEF_PATH,
     unsorted_clippy_utils_paths::UNSORTED_CLIPPY_UTILS_PATHS,
+    unusual_names::UNUSUAL_NAMES,
 ];
 
 pub fn register_lints(store: &mut LintStore) {
@@ -74,4 +76,5 @@ pub fn register_lints(store: &mut LintStore) {
     store.register_late_pass(|_| Box::new(outer_expn_data_pass::OuterExpnDataPass));
     store.register_late_pass(|_| Box::new(msrv_attr_impl::MsrvAttrImpl));
     store.register_late_pass(|_| Box::new(almost_standard_lint_formulation::AlmostStandardFormulation::new()));
+    store.register_late_pass(|_| Box::new(unusual_names::UnusualNames));
 }

clippy_lints_internal/src/unusual_names.rs

@@ -0,0 +1,47 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::sym;
+use rustc_hir::{PatKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use crate::internal_paths::APPLICABILITY;
+
+declare_tool_lint! {
+    /// ### What it does
+    /// Checks if variables of some types use the usual name.
+    ///
+    /// ### Why is this bad?
+    /// Restricting the identifiers used for common things in
+    /// Clippy sources increases consistency.
+    ///
+    /// ### Example
+    /// Check that an `rustc_errors::Applicability` variable is
+    /// named either `app` or `applicability`, and not
+    /// `a` or `appl`.
+    pub clippy::UNUSUAL_NAMES,
+    Warn,
+    "commonly used concepts should use usual same variable name.",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(UnusualNames => [UNUSUAL_NAMES]);
+
+impl<'tcx> LateLintPass<'tcx> for UnusualNames {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let StmtKind::Let(let_stmt) = stmt.kind
+            && let PatKind::Binding(_, _, ident, _) = let_stmt.pat.kind
+            && let Some(init_expr) = let_stmt.init
+            && !matches!(ident.name, sym::app | sym::applicability)
+            && APPLICABILITY.matches_ty(cx, cx.typeck_results().expr_ty(init_expr))
+        {
+            span_lint_and_help(
+                cx,
+                UNUSUAL_NAMES,
+                ident.span,
+                "unusual name for a variable of type `rustc_errors::Applicability`",
+                None,
+                "consider using `app` or `applicability`",
+            );
+        }
+    }
+}

clippy_utils/src/sym.rs

@@ -34,6 +34,7 @@ macro_rules! generate {
 //
 // `cargo dev fmt` ensures that the content of the `generate!()` macro call stays sorted.
 generate! {
+    Applicability,
     AsyncReadExt,
     AsyncWriteExt,
     BACKSLASH_SINGLE_QUOTE: r"\'",
@@ -75,7 +76,9 @@ generate! {
     Weak,
     abs,
     ambiguous_glob_reexports,
+    app,
     append,
+    applicability,
     arg,
     as_bytes,
     as_deref,
@@ -285,6 +288,7 @@ generate! {
     rsplit_terminator,
     rsplitn,
     rsplitn_mut,
+    rustc_errors,
     rustc_lint,
     rustc_lint_defs,
     rustc_span,