From 8f5b4f3f5ca62ddb79a0337035919ef488acc9d4 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Wed, 13 Nov 2019 08:26:52 +0200
Subject: [PATCH] literal representation restructure 1

Combine macro expansion checks. Indentation is a little strange to
avoid rustfmt issue.
---
 clippy_lints/src/literal_representation.rs | 98 +++++++++++-----------
 1 file changed, 47 insertions(+), 51 deletions(-)

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 8ddd54bb7a3..8b978338922 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -358,67 +358,63 @@ impl EarlyLintPass for LiteralDigitGrouping {
 impl LiteralDigitGrouping {
     fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
         let in_macro = in_macro(lit.span);
+
+        if_chain! {
+            if let Some(src) = snippet_opt(cx, lit.span);
+            if let Some(firstch) = src.chars().next();
+            if char::is_digit(firstch, 10);
+            then {
+
+
         match lit.kind {
             LitKind::Int(..) => {
                 // Lint integral literals.
-                if_chain! {
-                    if let Some(src) = snippet_opt(cx, lit.span);
-                    if let Some(firstch) = src.chars().next();
-                    if char::is_digit(firstch, 10);
-                    then {
-                        let digit_info = DigitInfo::new(&src, false);
-                        let _ = Self::do_lint(digit_info.digits, digit_info.suffix, in_macro).map_err(|warning_type| {
-                            warning_type.display(&digit_info.grouping_hint(), cx, lit.span)
-                        });
-                    }
-                }
+                let digit_info = DigitInfo::new(&src, false);
+                let _ = Self::do_lint(digit_info.digits, digit_info.suffix, in_macro).map_err(|warning_type| {
+                    warning_type.display(&digit_info.grouping_hint(), cx, lit.span)
+                });
             },
             LitKind::Float(..) => {
                 // Lint floating-point literals.
-                if_chain! {
-                    if let Some(src) = snippet_opt(cx, lit.span);
-                    if let Some(firstch) = src.chars().next();
-                    if char::is_digit(firstch, 10);
-                    then {
-                        let digit_info = DigitInfo::new(&src, true);
-                        // Separate digits into integral and fractional parts.
-                        let parts: Vec<&str> = digit_info
-                            .digits
-                            .split_terminator('.')
-                            .collect();
+                let digit_info = DigitInfo::new(&src, true);
+                // Separate digits into integral and fractional parts.
+                let parts: Vec<&str> = digit_info
+                    .digits
+                    .split_terminator('.')
+                    .collect();
 
-                        // Lint integral and fractional parts separately, and then check consistency of digit
-                        // groups if both pass.
-                        let _ = Self::do_lint(parts[0], digit_info.suffix, in_macro)
-                            .map(|integral_group_size| {
-                                if parts.len() > 1 {
-                                    // Lint the fractional part of literal just like integral part, but reversed.
-                                    let fractional_part = &parts[1].chars().rev().collect::<String>();
-                                    let _ = Self::do_lint(fractional_part, None, in_macro)
-                                        .map(|fractional_group_size| {
-                                            let consistent = Self::parts_consistent(integral_group_size,
-                                                                                    fractional_group_size,
-                                                                                    parts[0].len(),
-                                                                                    parts[1].len());
-                                                if !consistent {
-                                                    WarningType::InconsistentDigitGrouping.display(
-                                                        &digit_info.grouping_hint(),
-                                                        cx,
-                                                        lit.span,
-                                                    );
-                                                }
-                                        })
-                                    .map_err(|warning_type| warning_type.display(&digit_info.grouping_hint(),
-                                    cx,
-                                    lit.span));
-                                }
-                            })
-                        .map_err(|warning_type| warning_type.display(&digit_info.grouping_hint(), cx, lit.span));
-                    }
-                }
+                // Lint integral and fractional parts separately, and then check consistency of digit
+                // groups if both pass.
+                let _ = Self::do_lint(parts[0], digit_info.suffix, in_macro)
+                    .map(|integral_group_size| {
+                        if parts.len() > 1 {
+                            // Lint the fractional part of literal just like integral part, but reversed.
+                            let fractional_part = &parts[1].chars().rev().collect::<String>();
+                            let _ = Self::do_lint(fractional_part, None, in_macro)
+                                .map(|fractional_group_size| {
+                                    let consistent = Self::parts_consistent(integral_group_size,
+                                                                            fractional_group_size,
+                                                                            parts[0].len(),
+                                                                            parts[1].len());
+                                        if !consistent {
+                                            WarningType::InconsistentDigitGrouping.display(
+                                                &digit_info.grouping_hint(),
+                                                cx,
+                                                lit.span,
+                                            );
+                                        }
+                                })
+                            .map_err(|warning_type| warning_type.display(&digit_info.grouping_hint(),
+                            cx,
+                            lit.span));
+                        }
+                    })
+                .map_err(|warning_type| warning_type.display(&digit_info.grouping_hint(), cx, lit.span));
             },
             _ => (),
         }
+            }
+        }
     }
 
     /// Given the sizes of the digit groups of both integral and fractional