Add style configuration for unseparated_literal_suffix

This commit adds a configuration `literal-suffix-style` to enforce a
specific style for unseparated_literal_suffix. The configuration accepts
two values:
- "separated"
    enforce all literals to be written separately (e.g. `123_i32`)
- "unseparated"
    enforce all literals to be written as unseparated (e.g. `123i32`)

Not specifying a value means that there is no preference on style and
any style should not be warned.

Author: dswij

clippy_lints/src/lib.rs

@@ -435,7 +435,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
     store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
     store.register_early_pass(|| Box::new(formatting::Formatting));
-    store.register_early_pass(|| Box::new(misc_early::MiscEarlyLints));
+    let literal_suffix_style = conf.literal_suffix_style.clone();
+    store.register_early_pass(move || Box::new(misc_early::MiscEarlyLints::new(literal_suffix_style.clone())));
     store.register_early_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
     store.register_late_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
     store.register_early_pass(|| Box::new(unused_unit::UnusedUnit));

clippy_lints/src/misc_early/double_neg.rs

@@ -1,23 +1,18 @@
-use super::MiscEarlyLints;
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Expr, ExprKind, UnOp};
 use rustc_lint::EarlyContext;
 
 use super::DOUBLE_NEG;
 
 pub(super) fn check(cx: &EarlyContext<'_>, expr: &Expr) {
-    match expr.kind {
-        ExprKind::Unary(UnOp::Neg, ref inner) => {
-            if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
-                span_lint(
-                    cx,
-                    DOUBLE_NEG,
-                    expr.span,
-                    "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
-                );
-            }
-        },
-        ExprKind::Lit(ref lit) => MiscEarlyLints::check_lit(cx, lit),
-        _ => (),
+    if let ExprKind::Unary(UnOp::Neg, ref inner) = expr.kind {
+        if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
+            span_lint(
+                cx,
+                DOUBLE_NEG,
+                expr.span,
+                "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
+            );
+        }
     }
 }

clippy_lints/src/misc_early/mod.rs

@@ -9,12 +9,12 @@ mod zero_prefixed_literal;
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
+use rustc_ast::ast::{Expr, ExprKind, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
@@ -113,20 +113,35 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if literal suffixes are not separated by an
-    /// underscore.
+    /// If `literal-suffix-stylle` = "separated", warns literal suffixes that are not separated by an
+    /// underscore
+    /// e.g `123i32`
     ///
-    /// ### Why is this bad?
-    /// It is much less readable.
+    /// If `literal-suffix-style` = "unseparated", warns literal suffixes that  are separated by an
+    /// underscore
+    /// e.g. `123_i32`
+    ///
+    /// else, any style of literal_suffix is allowed
     ///
     /// ### Example
+    ///
+    /// #### "separated"
     /// ```rust
     /// // Bad
     /// let y = 123832i32;
     ///
     /// // Good
     /// let y = 123832_i32;
     /// ```
+    ///
+    /// #### "unseparated"
+    /// ```rust
+    /// // Bad
+    /// let y = 123832_i32;
+    ///
+    /// // Good
+    /// let y = 123832i32;
+    /// ```
     pub UNSEPARATED_LITERAL_SUFFIX,
     restriction,
     "literals whose suffix is not separated by an underscore"
@@ -254,7 +269,12 @@ declare_clippy_lint! {
     "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
 }
 
-declare_lint_pass!(MiscEarlyLints => [
+#[allow(clippy::module_name_repetitions)]
+pub struct MiscEarlyLints {
+    literal_suffix_style: Option<LiteralSuffixStyle>,
+}
+
+impl_lint_pass!(MiscEarlyLints => [
     UNNEEDED_FIELD_PATTERN,
     DUPLICATE_UNDERSCORE_ARGUMENT,
     DOUBLE_NEG,
@@ -310,12 +330,29 @@ impl EarlyLintPass for MiscEarlyLints {
         if in_external_macro(cx.sess, expr.span) {
             return;
         }
+
+        if let ExprKind::Lit(ref lit) = expr.kind {
+            self.check_lit(cx, lit);
+        }
         double_neg::check(cx, expr);
     }
 }
 
 impl MiscEarlyLints {
-    fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
+    pub fn new(suffix_style: Option<String>) -> Self {
+        let literal_suffix_style = match suffix_style {
+            Some(style) => match style.as_str() {
+                "unseparated" => Some(LiteralSuffixStyle::Unseparated),
+                "separated" => Some(LiteralSuffixStyle::Separated),
+                _ => None,
+            },
+            _ => None,
+        };
+
+        Self { literal_suffix_style }
+    }
+
+    fn check_lit(&self, cx: &EarlyContext<'_>, lit: &Lit) {
         // We test if first character in snippet is a number, because the snippet could be an expansion
         // from a built-in macro like `line!()` or a proc-macro like `#[wasm_bindgen]`.
         // Note that this check also covers special case that `line!()` is eagerly expanded by compiler.
@@ -332,7 +369,7 @@ impl MiscEarlyLints {
                 LitIntType::Unsigned(ty) => ty.name_str(),
                 LitIntType::Unsuffixed => "",
             };
-            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer", self.literal_suffix_style);
             if lit_snip.starts_with("0x") {
                 mixed_case_hex_literals::check(cx, lit, suffix, &lit_snip);
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
@@ -342,7 +379,13 @@ impl MiscEarlyLints {
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
             let suffix = float_ty.name_str();
-            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float");
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float", self.literal_suffix_style);
         }
     }
 }
+
+#[derive(Copy, Clone)]
+enum LiteralSuffixStyle {
+    Unseparated,
+    Separated,
+}

clippy_lints/src/misc_early/unseparated_literal_suffix.rs

@@ -3,24 +3,54 @@ use rustc_ast::ast::Lit;
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 
-use super::UNSEPARATED_LITERAL_SUFFIX;
+use super::{LiteralSuffixStyle, UNSEPARATED_LITERAL_SUFFIX};
 
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
+pub(super) fn check(
+    cx: &EarlyContext<'_>,
+    lit: &Lit,
+    lit_snip: &str,
+    suffix: &str,
+    sugg_type: &str,
+    style_opt: Option<LiteralSuffixStyle>,
+) {
+    let style = if let Some(suffix_style) = style_opt {
+        suffix_style
+    } else {
+        return;
+    };
     let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
         val
     } else {
         return; // It's useless so shouldn't lint.
     };
-    // Do not lint when literal is unsuffixed.
-    if !suffix.is_empty() && lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
-        span_lint_and_sugg(
-            cx,
-            UNSEPARATED_LITERAL_SUFFIX,
-            lit.span,
-            &format!("{} type suffix should be separated by an underscore", sugg_type),
-            "add an underscore",
-            format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
-            Applicability::MachineApplicable,
-        );
+
+    if suffix.is_empty() {
+        return;
+    }
+
+    match style {
+        LiteralSuffixStyle::Separated if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' => {
+            span_lint_and_sugg(
+                cx,
+                UNSEPARATED_LITERAL_SUFFIX,
+                lit.span,
+                &format!("{} type suffix should be separated by an underscore", sugg_type),
+                "add an underscore",
+                format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
+                Applicability::MachineApplicable,
+            );
+        },
+        LiteralSuffixStyle::Unseparated if lit_snip.as_bytes()[maybe_last_sep_idx] == b'_' => {
+            span_lint_and_sugg(
+                cx,
+                UNSEPARATED_LITERAL_SUFFIX,
+                lit.span,
+                &format!("{} type suffix should not be separated by an underscore", sugg_type),
+                "remove the underscore",
+                lit_snip[..=maybe_last_sep_idx].to_string(),
+                Applicability::MachineApplicable,
+            );
+        },
+        _ => (),
     }
 }

clippy_lints/src/utils/conf.rs

@@ -288,6 +288,14 @@ define_Conf! {
     ///
     /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
     (enable_raw_pointer_heuristic_for_send: bool = true),
+    /// Lint: UNSEPARATED_LITERAL_SUFFIX
+    ///
+    /// Configure a specific style for writing literal suffix.
+    /// Possible Options:
+    /// - "unseparated" : enforce writing prefix without underscore `_`
+    /// - "separated"   : enforce writing prefix with underscore `_`
+    /// - None          : no style preference
+    (literal_suffix_style: Option<String> = None),
 }
 
 /// Search for the configuration file.