move unneeded_field_pattern to its own module

Author: TaKO8Ki

clippy_lints/src/misc_early/mod.rs

@@ -1,9 +1,10 @@
 mod builtin_type_shadow;
 mod double_neg;
 mod redundant_pattern;
+mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
@@ -271,71 +272,7 @@ impl EarlyLintPass for MiscEarlyLints {
     }
 
     fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
-        if let PatKind::Struct(ref npat, ref pfields, _) = pat.kind {
-            let mut wilds = 0;
-            let type_name = npat
-                .segments
-                .last()
-                .expect("A path must have at least one segment")
-                .ident
-                .name;
-
-            for field in pfields {
-                if let PatKind::Wild = field.pat.kind {
-                    wilds += 1;
-                }
-            }
-            if !pfields.is_empty() && wilds == pfields.len() {
-                span_lint_and_help(
-                    cx,
-                    UNNEEDED_FIELD_PATTERN,
-                    pat.span,
-                    "all the struct fields are matched to a wildcard pattern, consider using `..`",
-                    None,
-                    &format!("try with `{} {{ .. }}` instead", type_name),
-                );
-                return;
-            }
-            if wilds > 0 {
-                for field in pfields {
-                    if let PatKind::Wild = field.pat.kind {
-                        wilds -= 1;
-                        if wilds > 0 {
-                            span_lint(
-                                cx,
-                                UNNEEDED_FIELD_PATTERN,
-                                field.span,
-                                "you matched a field with a wildcard pattern, consider using `..` instead",
-                            );
-                        } else {
-                            let mut normal = vec![];
-
-                            for field in pfields {
-                                match field.pat.kind {
-                                    PatKind::Wild => {},
-                                    _ => {
-                                        if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
-                                            normal.push(n);
-                                        }
-                                    },
-                                }
-                            }
-
-                            span_lint_and_help(
-                                cx,
-                                UNNEEDED_FIELD_PATTERN,
-                                field.span,
-                                "you matched a field with a wildcard pattern, consider using `..` \
-                                 instead",
-                                None,
-                                &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
-                            );
-                        }
-                    }
-                }
-            }
-        }
-
+        unneeded_field_pattern::check(cx, pat);
         redundant_pattern::check(cx, pat);
         unneeded_wildcard_pattern::check(cx, pat);
     }

clippy_lints/src/misc_early/unneeded_field_pattern.rs

@@ -0,0 +1,72 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use rustc_ast::ast::{Pat, PatKind};
+use rustc_lint::{EarlyContext, LintContext};
+
+use super::UNNEEDED_FIELD_PATTERN;
+
+pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
+    if let PatKind::Struct(ref npat, ref pfields, _) = pat.kind {
+        let mut wilds = 0;
+        let type_name = npat
+            .segments
+            .last()
+            .expect("A path must have at least one segment")
+            .ident
+            .name;
+
+        for field in pfields {
+            if let PatKind::Wild = field.pat.kind {
+                wilds += 1;
+            }
+        }
+        if !pfields.is_empty() && wilds == pfields.len() {
+            span_lint_and_help(
+                cx,
+                UNNEEDED_FIELD_PATTERN,
+                pat.span,
+                "all the struct fields are matched to a wildcard pattern, consider using `..`",
+                None,
+                &format!("try with `{} {{ .. }}` instead", type_name),
+            );
+            return;
+        }
+        if wilds > 0 {
+            for field in pfields {
+                if let PatKind::Wild = field.pat.kind {
+                    wilds -= 1;
+                    if wilds > 0 {
+                        span_lint(
+                            cx,
+                            UNNEEDED_FIELD_PATTERN,
+                            field.span,
+                            "you matched a field with a wildcard pattern, consider using `..` instead",
+                        );
+                    } else {
+                        let mut normal = vec![];
+
+                        for field in pfields {
+                            match field.pat.kind {
+                                PatKind::Wild => {},
+                                _ => {
+                                    if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
+                                        normal.push(n);
+                                    }
+                                },
+                            }
+                        }
+
+                        span_lint_and_help(
+                            cx,
+                            UNNEEDED_FIELD_PATTERN,
+                            field.span,
+                            "you matched a field with a wildcard pattern, consider using `..` \
+                             instead",
+                            None,
+                            &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
+                        );
+                    }
+                }
+            }
+        }
+    }
+}