edit

Author: surechen

clippy_lints/src/large_enum_variant.rs

@@ -80,7 +80,9 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
         if let ItemKind::Enum(ref def, _) = item.kind {
             let ty = cx.tcx.type_of(item.def_id);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
-
+            if adt.variants.len() <= 1 {
+                return;
+            }
             let mut variants_size: Vec<VariantInfo> = adt
                 .variants
                 .iter()
@@ -110,69 +112,67 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                 })
                 .collect();
 
-            if variants_size.len() >= 2 {
-                variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
+            variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
 
-                let mut difference = variants_size[0].size - variants_size[1].size;
-                if difference > self.maximum_size_difference_allowed {
-                    let help_text = "consider boxing the large fields to reduce the total size of the enum";
-                    span_lint_and_then(
-                        cx,
-                        LARGE_ENUM_VARIANT,
-                        def.variants[variants_size[0].ind].span,
-                        "large size difference between variants",
-                        |diag| {
-                            diag.span_label(
-                                def.variants[variants_size[0].ind].span,
-                                &format!("this variant is {} bytes", variants_size[0].size),
-                            );
-                            diag.span_note(
-                                def.variants[variants_size[1].ind].span,
-                                &format!("and the second-largest variant is {} bytes:", variants_size[1].size),
-                            );
+            let mut difference = variants_size[0].size - variants_size[1].size;
+            if difference > self.maximum_size_difference_allowed {
+                let help_text = "consider boxing the large fields to reduce the total size of the enum";
+                span_lint_and_then(
+                    cx,
+                    LARGE_ENUM_VARIANT,
+                    def.variants[variants_size[0].ind].span,
+                    "large size difference between variants",
+                    |diag| {
+                        diag.span_label(
+                            def.variants[variants_size[0].ind].span,
+                            &format!("this variant is {} bytes", variants_size[0].size),
+                        );
+                        diag.span_note(
+                            def.variants[variants_size[1].ind].span,
+                            &format!("and the second-largest variant is {} bytes:", variants_size[1].size),
+                        );
 
-                            let fields = def.variants[variants_size[0].ind].data.fields();
-                            variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
-                            let mut applicability = Applicability::MaybeIncorrect;
-                            let sugg: Vec<(Span, String)> = variants_size[0]
-                                .fields_size
-                                .iter()
-                                .rev()
-                                .take_while(|val| {
-                                    let judge = difference > self.maximum_size_difference_allowed;
-                                    difference = if difference > val.size {
-                                        difference - val.size
-                                    } else {
-                                        0
-                                    };
-                                    judge
-                                })
-                                .map(|val| {
-                                    (
-                                        fields[val.ind].ty.span,
-                                        format!(
-                                            "Box<{}>",
-                                            snippet_with_applicability(
-                                                cx,
-                                                fields[val.ind].ty.span,
-                                                "..",
-                                                &mut applicability
-                                            )
-                                            .into_owned()
-                                        ),
-                                    )
-                                })
-                                .collect();
+                        let fields = def.variants[variants_size[0].ind].data.fields();
+                        variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
+                        let mut applicability = Applicability::MaybeIncorrect;
+                        let sugg: Vec<(Span, String)> = variants_size[0]
+                            .fields_size
+                            .iter()
+                            .rev()
+                            .take_while(|val| {
+                                let judge = difference > self.maximum_size_difference_allowed;
+                                difference = if difference > val.size {
+                                    difference - val.size
+                                } else {
+                                    0
+                                };
+                                judge
+                            })
+                            .map(|val| {
+                                (
+                                    fields[val.ind].ty.span,
+                                    format!(
+                                        "Box<{}>",
+                                        snippet_with_applicability(
+                                            cx,
+                                            fields[val.ind].ty.span,
+                                            "..",
+                                            &mut applicability
+                                        )
+                                        .into_owned()
+                                    ),
+                                )
+                            })
+                            .collect();
 
-                            if !sugg.is_empty() {
-                                diag.multipart_suggestion(help_text, sugg, Applicability::MaybeIncorrect);
-                                return;
-                            }
+                        if !sugg.is_empty() {
+                            diag.multipart_suggestion(help_text, sugg, Applicability::MaybeIncorrect);
+                            return;
+                        }
 
-                            diag.span_help(def.variants[variants_size[0].ind].span, help_text);
-                        },
-                    );
-                }
+                        diag.span_help(def.variants[variants_size[0].ind].span, help_text);
+                    },
+                );
             }
         }
     }