src/tools/clippy/clippy_lints/src/large_enum_variant.rs

   1 //! lint when there is a large size difference between variants on an enum
   2
   3 use clippy_utils::diagnostics::span_lint_and_then;
   4 use clippy_utils::source::snippet_with_applicability;
   5 use rustc_errors::Applicability;
   6 use rustc_hir::{Item, ItemKind};
   7 use rustc_lint::{LateContext, LateLintPass};
   8 use rustc_middle::lint::in_external_macro;
   9 use rustc_middle::ty::layout::LayoutOf;
  10 use rustc_session::{declare_tool_lint, impl_lint_pass};
  11 use rustc_span::source_map::Span;
  12
  13 declare_clippy_lint! {
  14     /// ### What it does
  15     /// Checks for large size differences between variants on
  16     /// `enum`s.
  17     ///
  18     /// ### Why is this bad?
  19     /// Enum size is bounded by the largest variant. Having a
  20     /// large variant can penalize the memory layout of that enum.
  21     ///
  22     /// ### Known problems
  23     /// This lint obviously cannot take the distribution of
  24     /// variants in your running program into account. It is possible that the
  25     /// smaller variants make up less than 1% of all instances, in which case
  26     /// the overhead is negligible and the boxing is counter-productive. Always
  27     /// measure the change this lint suggests.
  28     ///
  29     /// ### Example
  30     /// ```rust
  31     /// // Bad
  32     /// enum Test {
  33     ///     A(i32),
  34     ///     B([i32; 8000]),
  35     /// }
  36     ///
  37     /// // Possibly better
  38     /// enum Test2 {
  39     ///     A(i32),
  40     ///     B(Box<[i32; 8000]>),
  41     /// }
  42     /// ```
  43     #[clippy::version = "pre 1.29.0"]
  44     pub LARGE_ENUM_VARIANT,
  45     perf,
  46     "large size difference between variants on an enum"
  47 }
  48
  49 #[derive(Copy, Clone)]
  50 pub struct LargeEnumVariant {
  51     maximum_size_difference_allowed: u64,
  52 }
  53
  54 impl LargeEnumVariant {
  55     #[must_use]
  56     pub fn new(maximum_size_difference_allowed: u64) -> Self {
  57         Self {
  58             maximum_size_difference_allowed,
  59         }
  60     }
  61 }
  62
  63 struct FieldInfo {
  64     ind: usize,
  65     size: u64,
  66 }
  67
  68 struct VariantInfo {
  69     ind: usize,
  70     size: u64,
  71     fields_size: Vec<FieldInfo>,
  72 }
  73
  74 impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
  75
  76 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
  77     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
  78         if in_external_macro(cx.tcx.sess, item.span) {
  79             return;
  80         }
  81         if let ItemKind::Enum(ref def, _) = item.kind {
  82             let ty = cx.tcx.type_of(item.def_id);
  83             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
  84             if adt.variants.len() <= 1 {
  85                 return;
  86             }
  87             let mut variants_size: Vec<VariantInfo> = adt
  88                 .variants
  89                 .iter()
  90                 .enumerate()
  91                 .map(|(i, variant)| {
  92                     let mut fields_size = Vec::new();
  93                     let size: u64 = variant
  94                         .fields
  95                         .iter()
  96                         .enumerate()
  97                         .filter_map(|(i, f)| {
  98                             let ty = cx.tcx.type_of(f.did);
  99                             // don't count generics by filtering out everything
 100                             // that does not have a layout
 101                             cx.layout_of(ty).ok().map(|l| {
 102                                 let size = l.size.bytes();
 103                                 fields_size.push(FieldInfo { ind: i, size });
 104                                 size
 105                             })
 106                         })
 107                         .sum();
 108                     VariantInfo {
 109                         ind: i,
 110                         size,
 111                         fields_size,
 112                     }
 113                 })
 114                 .collect();
 115
 116             variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
 117
 118             let mut difference = variants_size[0].size - variants_size[1].size;
 119             if difference > self.maximum_size_difference_allowed {
 120                 let help_text = "consider boxing the large fields to reduce the total size of the enum";
 121                 span_lint_and_then(
 122                     cx,
 123                     LARGE_ENUM_VARIANT,
 124                     def.variants[variants_size[0].ind].span,
 125                     "large size difference between variants",
 126                     |diag| {
 127                         diag.span_label(
 128                             def.variants[variants_size[0].ind].span,
 129                             &format!("this variant is {} bytes", variants_size[0].size),
 130                         );
 131                         diag.span_note(
 132                             def.variants[variants_size[1].ind].span,
 133                             &format!("and the second-largest variant is {} bytes:", variants_size[1].size),
 134                         );
 135
 136                         let fields = def.variants[variants_size[0].ind].data.fields();
 137                         variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
 138                         let mut applicability = Applicability::MaybeIncorrect;
 139                         let sugg: Vec<(Span, String)> = variants_size[0]
 140                             .fields_size
 141                             .iter()
 142                             .rev()
 143                             .map_while(|val| {
 144                                 if difference > self.maximum_size_difference_allowed {
 145                                     difference = difference.saturating_sub(val.size);
 146                                     Some((
 147                                         fields[val.ind].ty.span,
 148                                         format!(
 149                                             "Box<{}>",
 150                                             snippet_with_applicability(
 151                                                 cx,
 152                                                 fields[val.ind].ty.span,
 153                                                 "..",
 154                                                 &mut applicability
 155                                             )
 156                                             .into_owned()
 157                                         ),
 158                                     ))
 159                                 } else {
 160                                     None
 161                                 }
 162                             })
 163                             .collect();
 164
 165                         if !sugg.is_empty() {
 166                             diag.multipart_suggestion(help_text, sugg, Applicability::MaybeIncorrect);
 167                             return;
 168                         }
 169
 170                         diag.span_help(def.variants[variants_size[0].ind].span, help_text);
 171                     },
 172                 );
 173             }
 174         }
 175     }
 176 }