Add new lint unneeded_struct_pattern

CHANGELOG.md

@@ -6042,6 +6042,7 @@ Released 2018-09-13
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
 [`unnecessary_wraps`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
+[`unneeded_struct_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_struct_pattern
 [`unneeded_wildcard_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_wildcard_pattern
 [`unnested_or_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
 [`unreachable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreachable

clippy_lints/src/declared_lints.rs

@@ -740,6 +740,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO,
     crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO,
     crate::unnecessary_wraps::UNNECESSARY_WRAPS_INFO,
+    crate::unneeded_struct_pattern::UNNEEDED_STRUCT_PATTERN_INFO,
     crate::unnested_or_patterns::UNNESTED_OR_PATTERNS_INFO,
     crate::unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME_INFO,
     crate::unused_async::UNUSED_ASYNC_INFO,

clippy_lints/src/lib.rs

@@ -368,6 +368,7 @@ mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
 mod unnecessary_struct_initialization;
 mod unnecessary_wraps;
+mod unneeded_struct_pattern;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_async;
@@ -944,5 +945,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(manual_is_power_of_two::ManualIsPowerOfTwo));
     store.register_late_pass(|_| Box::new(non_zero_suggestions::NonZeroSuggestions));
     store.register_late_pass(move |_| Box::new(unused_trait_names::UnusedTraitNames::new(conf)));
+    store.register_late_pass(|_| Box::new(unneeded_struct_pattern::UnneededStructPattern));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

clippy_lints/src/unneeded_struct_pattern.rs

@@ -0,0 +1,71 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Pat, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for struct patterns that match against unit variant.
+    ///
+    /// ### Why is this bad?
+    /// Struct pattern `{ }` or `{ .. }` is not needed for unit variant.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// match Some(42) {
+    ///     Some(v) => v,
+    ///     None { .. } => 0,
+    /// }
+    /// // Or
+    /// match Some(42) {
+    ///     Some(v) => v,
+    ///     None { } => 0,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// match Some(42) {
+    ///     Some(v) => v,
+    ///     None => 0,
+    /// }
+    /// ```
+    #[clippy::version = "1.83.0"]
+    pub UNNEEDED_STRUCT_PATTERN,
+    nursery,
+    "using struct pattern to match against unit variant"
+}
+
+declare_lint_pass!(UnneededStructPattern => [UNNEEDED_STRUCT_PATTERN]);
+
+impl LateLintPass<'_> for UnneededStructPattern {
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
+        if !pat.span.from_expansion()
+            && let PatKind::Struct(path, [], _) = &pat.kind
+            && let QPath::Resolved(_, path) = path
+            && let Res::Def(DefKind::Variant, did) = path.res
+        {
+            let enum_did = cx.tcx.parent(did);
+            let variant = cx.tcx.adt_def(enum_did).variant_with_id(did);
+
+            let has_fields_brackets = !(variant.ctor.is_some() && variant.fields.is_empty());
+            let non_exhaustive_activated = !variant.def_id.is_local() && variant.is_field_list_non_exhaustive();
+            if has_fields_brackets || non_exhaustive_activated {
+                return;
+            }
+
+            if let Some(brackets_span) = pat.span.trim_start(path.span) {
+                span_lint_and_sugg(
+                    cx,
+                    UNNEEDED_STRUCT_PATTERN,
+                    brackets_span,
+                    "struct pattern is not needed for a unit variant",
+                    "remove the struct pattern",
+                    String::new(),
+                    Applicability::Unspecified,
+                );
+            }
+        }
+    }
+}

tests/ui/auxiliary/non-exhaustive-enum.rs

@@ -6,3 +6,27 @@ pub enum ErrorKind {
     #[doc(hidden)]
     Uncategorized,
 }
+
+#[non_exhaustive]
+pub enum ExtNonExhaustiveEnum {
+    Unit,
+    Tuple(i32),
+    Struct { field: i32 },
+}
+
+pub enum ExtNonExhaustiveVariant {
+    ExhaustiveUnit,
+    #[non_exhaustive]
+    Unit,
+    // Currently, we can't match a non_exhaustive tuple from external crates
+    // See https://github.com/rust-lang/rust/issues/130891
+    //
+    // #[non_exhaustive]
+    // Tuple(i32),
+    #[non_exhaustive]
+    StructNoField {},
+    #[non_exhaustive]
+    Struct {
+        field: i32,
+    },
+}

tests/ui/unneeded_struct_pattern.fixed

@@ -0,0 +1,97 @@
+//@aux-build:non-exhaustive-enum.rs
+#![allow(clippy::manual_unwrap_or_default, clippy::manual_unwrap_or)]
+#![warn(clippy::unneeded_struct_pattern)]
+
+extern crate non_exhaustive_enum;
+use non_exhaustive_enum::*;
+
+fn main() {
+    match Some(114514) {
+        Some(v) => v,
+        None => 0,
+    };
+
+    match Some(1919810) {
+        Some(v) => v,
+        None => 0,
+    };
+
+    match Some(123456) {
+        Some(v) => v,
+        None => 0,
+    };
+
+    match Some(Some(123456)) {
+        Some(Some(v)) => v,
+        Some(None) => 0,
+        None => 0,
+    };
+
+    enum Custom {
+        HasFields {
+            field: i32,
+        },
+        HasBracketsNoFields {},
+        NoBrackets,
+        #[non_exhaustive]
+        NoBracketsNonExhaustive,
+        Init,
+    };
+
+    match Custom::Init {
+        Custom::HasFields { field: value } => value, // Should be ignored
+        Custom::HasBracketsNoFields {} => 0,         // Should be ignored
+        Custom::NoBrackets => 0,                  // Should be fixed
+        Custom::NoBracketsNonExhaustive => 0,     // Should be fixed
+        _ => 0,
+    };
+
+    match Custom::Init {
+        Custom::HasFields { field: value } => value, // Should be ignored
+        Custom::HasBracketsNoFields { .. } => 0,     // Should be ignored
+        Custom::NoBrackets => 0,              // Should be fixed
+        Custom::NoBracketsNonExhaustive => 0, // Should be fixed
+        _ => 0,
+    };
+
+    match Custom::Init {
+        Custom::NoBrackets if true => 0, // Should be fixed
+        _ => 0,
+    };
+
+    match Custom::Init {
+        Custom::NoBrackets | Custom::NoBracketsNonExhaustive => 0, // Should be fixed
+        _ => 0,
+    };
+}
+
+fn external_crate() {
+    use ExtNonExhaustiveVariant::*;
+
+    match ExhaustiveUnit {
+        // Expected
+        ExhaustiveUnit => 0,
+        _ => 0,
+    };
+
+    match ExhaustiveUnit {
+        // Exhaustive variant, should be fixed
+        ExhaustiveUnit => 0,
+        _ => 0,
+    };
+
+    match ExhaustiveUnit {
+        // Exhaustive variant, should be fixed
+        ExhaustiveUnit => 0,
+        _ => 0,
+    };
+
+    match ExhaustiveUnit {
+        ExhaustiveUnit => 0,
+        // vvvvv Non-exhaustive variants, should all be ignored
+        Unit { .. } => 0,
+        StructNoField { .. } => 0,
+        Struct { field, .. } => field,
+        _ => 0,
+    };
+}

tests/ui/unneeded_struct_pattern.rs

@@ -0,0 +1,97 @@
+//@aux-build:non-exhaustive-enum.rs
+#![allow(clippy::manual_unwrap_or_default, clippy::manual_unwrap_or)]
+#![warn(clippy::unneeded_struct_pattern)]
+
+extern crate non_exhaustive_enum;
+use non_exhaustive_enum::*;
+
+fn main() {
+    match Some(114514) {
+        Some(v) => v,
+        None {} => 0,
+    };
+
+    match Some(1919810) {
+        Some(v) => v,
+        None { .. } => 0,
+    };
+
+    match Some(123456) {
+        Some(v) => v,
+        None => 0,
+    };
+
+    match Some(Some(123456)) {
+        Some(Some(v)) => v,
+        Some(None {}) => 0,
+        None {} => 0,
+    };
+
+    enum Custom {
+        HasFields {
+            field: i32,
+        },
+        HasBracketsNoFields {},
+        NoBrackets,
+        #[non_exhaustive]
+        NoBracketsNonExhaustive,
+        Init,
+    };
+
+    match Custom::Init {
+        Custom::HasFields { field: value } => value, // Should be ignored
+        Custom::HasBracketsNoFields {} => 0,         // Should be ignored
+        Custom::NoBrackets {} => 0,                  // Should be fixed
+        Custom::NoBracketsNonExhaustive {} => 0,     // Should be fixed
+        _ => 0,
+    };
+
+    match Custom::Init {
+        Custom::HasFields { field: value } => value, // Should be ignored
+        Custom::HasBracketsNoFields { .. } => 0,     // Should be ignored
+        Custom::NoBrackets { .. } => 0,              // Should be fixed
+        Custom::NoBracketsNonExhaustive { .. } => 0, // Should be fixed
+        _ => 0,
+    };
+
+    match Custom::Init {
+        Custom::NoBrackets {} if true => 0, // Should be fixed
+        _ => 0,
+    };
+
+    match Custom::Init {
+        Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} => 0, // Should be fixed
+        _ => 0,
+    };
+}
+
+fn external_crate() {
+    use ExtNonExhaustiveVariant::*;
+
+    match ExhaustiveUnit {
+        // Expected
+        ExhaustiveUnit => 0,
+        _ => 0,
+    };
+
+    match ExhaustiveUnit {
+        // Exhaustive variant, should be fixed
+        ExhaustiveUnit { .. } => 0,
+        _ => 0,
+    };
+
+    match ExhaustiveUnit {
+        // Exhaustive variant, should be fixed
+        ExhaustiveUnit {} => 0,
+        _ => 0,
+    };
+
+    match ExhaustiveUnit {
+        ExhaustiveUnit => 0,
+        // vvvvv Non-exhaustive variants, should all be ignored
+        Unit { .. } => 0,
+        StructNoField { .. } => 0,
+        Struct { field, .. } => field,
+        _ => 0,
+    };
+}