clippy_lints/src/large_enum_variant.rs

   1 //! lint when there is a large size difference between variants on an enum
   2
   3 use crate::utils::{snippet_opt, span_lint_and_then};
   4 use rustc_errors::Applicability;
   5 use rustc_hir::{Item, ItemKind, VariantData};
   6 use rustc_lint::{LateContext, LateLintPass};
   7 use rustc_middle::lint::in_external_macro;
   8 use rustc_session::{declare_tool_lint, impl_lint_pass};
   9 use rustc_target::abi::LayoutOf;
  10
  11 declare_clippy_lint! {
  12     /// **What it does:** Checks for large size differences between variants on
  13     /// `enum`s.
  14     ///
  15     /// **Why is this bad?** Enum size is bounded by the largest variant. Having a
  16     /// large variant can penalize the memory layout of that enum.
  17     ///
  18     /// **Known problems:** This lint obviously cannot take the distribution of
  19     /// variants in your running program into account. It is possible that the
  20     /// smaller variants make up less than 1% of all instances, in which case
  21     /// the overhead is negligible and the boxing is counter-productive. Always
  22     /// measure the change this lint suggests.
  23     ///
  24     /// **Example:**
  25     ///
  26     /// ```rust
  27     /// // Bad
  28     /// enum Test {
  29     ///     A(i32),
  30     ///     B([i32; 8000]),
  31     /// }
  32     ///
  33     /// // Possibly better
  34     /// enum Test2 {
  35     ///     A(i32),
  36     ///     B(Box<[i32; 8000]>),
  37     /// }
  38     /// ```
  39     pub LARGE_ENUM_VARIANT,
  40     perf,
  41     "large size difference between variants on an enum"
  42 }
  43
  44 #[derive(Copy, Clone)]
  45 pub struct LargeEnumVariant {
  46     maximum_size_difference_allowed: u64,
  47 }
  48
  49 impl LargeEnumVariant {
  50     #[must_use]
  51     pub fn new(maximum_size_difference_allowed: u64) -> Self {
  52         Self {
  53             maximum_size_difference_allowed,
  54         }
  55     }
  56 }
  57
  58 impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
  59
  60 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
  61     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
  62         if in_external_macro(cx.tcx.sess, item.span) {
  63             return;
  64         }
  65         let did = cx.tcx.hir().local_def_id(item.hir_id);
  66         if let ItemKind::Enum(ref def, _) = item.kind {
  67             let ty = cx.tcx.type_of(did);
  68             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
  69
  70             let mut largest_variant: Option<(_, _)> = None;
  71             let mut second_variant: Option<(_, _)> = None;
  72
  73             for (i, variant) in adt.variants.iter().enumerate() {
  74                 let size: u64 = variant
  75                     .fields
  76                     .iter()
  77                     .filter_map(|f| {
  78                         let ty = cx.tcx.type_of(f.did);
  79                         // don't count generics by filtering out everything
  80                         // that does not have a layout
  81                         cx.layout_of(ty).ok().map(|l| l.size.bytes())
  82                     })
  83                     .sum();
  84
  85                 let grouped = (size, (i, variant));
  86
  87                 if grouped.0 >= largest_variant.map_or(0, |x| x.0) {
  88                     second_variant = largest_variant;
  89                     largest_variant = Some(grouped);
  90                 }
  91             }
  92
  93             if let (Some(largest), Some(second)) = (largest_variant, second_variant) {
  94                 let difference = largest.0 - second.0;
  95
  96                 if difference > self.maximum_size_difference_allowed {
  97                     let (i, variant) = largest.1;
  98
  99                     let help_text = "consider boxing the large fields to reduce the total size of the enum";
 100                     span_lint_and_then(
 101                         cx,
 102                         LARGE_ENUM_VARIANT,
 103                         def.variants[i].span,
 104                         "large size difference between variants",
 105                         |diag| {
 106                             diag.span_label(
 107                                 def.variants[(largest.1).0].span,
 108                                 &format!("this variant is {} bytes", largest.0),
 109                             );
 110                             diag.span_note(
 111                                 def.variants[(second.1).0].span,
 112                                 &format!("and the second-largest variant is {} bytes:", second.0),
 113                             );
 114                             if variant.fields.len() == 1 {
 115                                 let span = match def.variants[i].data {
 116                                     VariantData::Struct(ref fields, ..) | VariantData::Tuple(ref fields, ..) => {
 117                                         fields[0].ty.span
 118                                     },
 119                                     VariantData::Unit(..) => unreachable!(),
 120                                 };
 121                                 if let Some(snip) = snippet_opt(cx, span) {
 122                                     diag.span_suggestion(
 123                                         span,
 124                                         help_text,
 125                                         format!("Box<{}>", snip),
 126                                         Applicability::MaybeIncorrect,
 127                                     );
 128                                     return;
 129                                 }
 130                             }
 131                             diag.span_help(def.variants[i].span, help_text);
 132                         },
 133                     );
 134                 }
 135             }
 136         }
 137     }
 138 }