1 use crate::utils::{snippet_opt, span_lint_and_then};
2 use if_chain::if_chain;
3 use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
4 use rustc_attr as attr;
5 use rustc_errors::Applicability;
6 use rustc_lint::{EarlyContext, EarlyLintPass};
7 use rustc_session::{declare_lint_pass, declare_tool_lint};
10 declare_clippy_lint! {
11 /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
13 /// **Why is this bad?** Using the #[non_exhaustive] attribute expresses better the intent
14 /// and allows possible optimizations when applied to enums.
16 /// **Known problems:** None.
34 /// struct T(pub i32, pub i32, ());
51 /// struct T(pub i32, pub i32);
53 pub MANUAL_NON_EXHAUSTIVE,
55 "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
58 declare_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
60 impl EarlyLintPass for ManualNonExhaustive {
61 fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
63 ItemKind::Enum(def, _) => {
64 check_manual_non_exhaustive_enum(cx, item, &def.variants);
66 ItemKind::Struct(variant_data, _) => {
67 if let VariantData::Unit(..) = variant_data {
71 check_manual_non_exhaustive_struct(cx, item, variant_data);
78 fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants: &[Variant]) {
79 fn is_non_exhaustive_marker(variant: &Variant) -> bool {
80 matches!(variant.data, VariantData::Unit(_))
81 && variant.ident.as_str().starts_with('_')
82 && variant.attrs.iter().any(|a| is_doc_hidden(a))
85 fn is_doc_hidden(attr: &Attribute) -> bool {
86 attr.check_name(sym!(doc))
87 && match attr.meta_item_list() {
88 Some(l) => attr::list_contains_name(&l, sym!(hidden)),
94 let mut markers = variants.iter().filter(|v| is_non_exhaustive_marker(v));
95 if let Some(marker) = markers.next();
96 if markers.count() == 0 && variants.len() > 1;
100 MANUAL_NON_EXHAUSTIVE,
102 "this seems like a manual implementation of the non-exhaustive pattern",
105 if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
106 let header_span = cx.sess.source_map().span_until_char(item.span, '{');
107 if let Some(snippet) = snippet_opt(cx, header_span);
109 diag.span_suggestion(
112 format!("#[non_exhaustive] {}", snippet),
113 Applicability::Unspecified,
117 diag.span_help(marker.span, "remove this variant");
123 fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data: &VariantData) {
124 fn is_private(field: &StructField) -> bool {
125 matches!(field.vis.node, VisibilityKind::Inherited)
128 fn is_non_exhaustive_marker(field: &StructField) -> bool {
129 is_private(field) && field.ty.kind.is_unit() && field.ident.map_or(true, |n| n.as_str().starts_with('_'))
132 fn find_header_span(cx: &EarlyContext<'_>, item: &Item, data: &VariantData) -> Span {
133 let delimiter = match data {
134 VariantData::Struct(..) => '{',
135 VariantData::Tuple(..) => '(',
136 VariantData::Unit(_) => unreachable!("`VariantData::Unit` is already handled above"),
139 cx.sess.source_map().span_until_char(item.span, delimiter)
142 let fields = data.fields();
143 let private_fields = fields.iter().filter(|f| is_private(f)).count();
144 let public_fields = fields.iter().filter(|f| f.vis.node.is_pub()).count();
147 if private_fields == 1 && public_fields >= 1 && public_fields == fields.len() - 1;
148 if let Some(marker) = fields.iter().find(|f| is_non_exhaustive_marker(f));
152 MANUAL_NON_EXHAUSTIVE,
154 "this seems like a manual implementation of the non-exhaustive pattern",
157 if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
158 let header_span = find_header_span(cx, item, data);
159 if let Some(snippet) = snippet_opt(cx, header_span);
161 diag.span_suggestion(
164 format!("#[non_exhaustive] {}", snippet),
165 Applicability::Unspecified,
169 diag.span_help(marker.span, "remove this field");