Revert "Add style configuration for unseparated_literal_suffix"

This reverts commit 87bb815baf78d122805ab8dc6c0251d380825a5b.

Author: dswij

clippy_lints/src/lib.rs

@@ -435,8 +435,7 @@ 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));
-    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(misc_early::MiscEarlyLints));
     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,18 +1,23 @@
+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) {
-    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",
-            );
-        }
+    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),
+        _ => (),
     }
 }

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, ExprKind, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
+use rustc_ast::ast::{Expr, 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_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
@@ -113,35 +113,20 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// If `literal-suffix-stylle` = "separated", warns literal suffixes that are not separated by an
-    /// underscore
-    /// e.g `123i32`
+    /// Warns if literal suffixes are not separated by an
+    /// underscore.
     ///
-    /// 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
+    /// ### Why is this bad?
+    /// It is much less readable.
     ///
     /// ### 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"
@@ -269,12 +254,7 @@ declare_clippy_lint! {
     "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
 }
 
-#[allow(clippy::module_name_repetitions)]
-pub struct MiscEarlyLints {
-    literal_suffix_style: Option<LiteralSuffixStyle>,
-}
-
-impl_lint_pass!(MiscEarlyLints => [
+declare_lint_pass!(MiscEarlyLints => [
     UNNEEDED_FIELD_PATTERN,
     DUPLICATE_UNDERSCORE_ARGUMENT,
     DOUBLE_NEG,
@@ -330,29 +310,12 @@ 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 {
-    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) {
+    fn check_lit(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.
@@ -369,7 +332,7 @@ impl MiscEarlyLints {
                 LitIntType::Unsigned(ty) => ty.name_str(),
                 LitIntType::Unsuffixed => "",
             };
-            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer", self.literal_suffix_style);
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
             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") {
@@ -379,13 +342,7 @@ 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", self.literal_suffix_style);
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float");
         }
     }
 }
-
-#[derive(Copy, Clone)]
-enum LiteralSuffixStyle {
-    Unseparated,
-    Separated,
-}

clippy_lints/src/misc_early/unseparated_literal_suffix.rs

@@ -3,54 +3,24 @@ use rustc_ast::ast::Lit;
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 
-use super::{LiteralSuffixStyle, UNSEPARATED_LITERAL_SUFFIX};
+use super::UNSEPARATED_LITERAL_SUFFIX;
 
-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;
-    };
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
     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.
     };
-
-    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,
-            );
-        },
-        _ => (),
+    // 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,
+        );
     }
 }

clippy_lints/src/utils/conf.rs

@@ -288,14 +288,6 @@ 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.