rust-clippy/clippy_lints/src/large_enum_variant.rs

135 lines
5.1 KiB
Rust
Raw Normal View History

//! lint when there is a large size difference between variants on an enum
2018-11-27 20:14:15 +00:00
use crate::utils::{snippet_opt, span_lint_and_then};
use rustc_errors::Applicability;
2020-02-21 08:39:38 +00:00
use rustc_hir::{Item, ItemKind, VariantData};
2020-01-12 06:08:41 +00:00
use rustc_lint::{LateContext, LateLintPass};
2020-01-11 11:37:08 +00:00
use rustc_session::{declare_tool_lint, impl_lint_pass};
2020-04-02 20:29:41 +00:00
use rustc_target::abi::LayoutOf;
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
/// **What it does:** Checks for large size differences between variants on
/// `enum`s.
///
/// **Why is this bad?** Enum size is bounded by the largest variant. Having a
/// large variant can penalize the memory layout of that enum.
///
/// **Known problems:** This lint obviously cannot take the distribution of
/// variants in your running program into account. It is possible that the
/// smaller variants make up less than 1% of all instances, in which case
/// the overhead is negligible and the boxing is counter-productive. Always
/// measure the change this lint suggests.
///
/// **Example:**
///
/// ```rust
/// // Bad
/// enum Test {
/// A(i32),
/// B([i32; 8000]),
/// }
///
/// // Possibly better
/// enum Test2 {
/// A(i32),
/// B(Box<[i32; 8000]>),
/// }
/// ```
pub LARGE_ENUM_VARIANT,
2018-03-28 13:24:26 +00:00
perf,
"large size difference between variants on an enum"
}
2017-08-09 07:30:56 +00:00
#[derive(Copy, Clone)]
pub struct LargeEnumVariant {
maximum_size_difference_allowed: u64,
}
impl LargeEnumVariant {
#[must_use]
pub fn new(maximum_size_difference_allowed: u64) -> Self {
2017-09-05 09:33:04 +00:00
Self {
maximum_size_difference_allowed,
2017-09-05 09:33:04 +00:00
}
}
}
2019-04-08 20:43:55 +00:00
impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
let did = cx.tcx.hir().local_def_id(item.hir_id);
2019-09-27 15:16:06 +00:00
if let ItemKind::Enum(ref def, _) = item.kind {
2017-04-27 12:00:35 +00:00
let ty = cx.tcx.type_of(did);
2018-11-27 20:14:15 +00:00
let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
let mut largest_variant: Option<(_, _)> = None;
let mut second_variant: Option<(_, _)> = None;
for (i, variant) in adt.variants.iter().enumerate() {
2017-08-09 07:30:56 +00:00
let size: u64 = variant
.fields
.iter()
.filter_map(|f| {
2017-04-27 12:00:35 +00:00
let ty = cx.tcx.type_of(f.did);
// don't count generics by filtering out everything
// that does not have a layout
cx.layout_of(ty).ok().map(|l| l.size.bytes())
})
.sum();
let grouped = (size, (i, variant));
if grouped.0 >= largest_variant.map_or(0, |x| x.0) {
second_variant = largest_variant;
largest_variant = Some(grouped);
}
}
if let (Some(largest), Some(second)) = (largest_variant, second_variant) {
let difference = largest.0 - second.0;
if difference > self.maximum_size_difference_allowed {
let (i, variant) = largest.1;
let help_text = "consider boxing the large fields to reduce the total size of the enum";
2017-08-09 07:30:56 +00:00
span_lint_and_then(
cx,
LARGE_ENUM_VARIANT,
def.variants[i].span,
"large size difference between variants",
|diag| {
diag.span_label(
def.variants[(largest.1).0].span,
&format!("this variant is {} bytes", largest.0),
);
diag.span_note(
def.variants[(second.1).0].span,
&format!("and the second-largest variant is {} bytes:", second.0),
);
2017-08-09 07:30:56 +00:00
if variant.fields.len() == 1 {
2019-08-15 07:59:08 +00:00
let span = match def.variants[i].data {
VariantData::Struct(ref fields, ..) | VariantData::Tuple(ref fields, ..) => {
2017-09-05 09:33:04 +00:00
fields[0].ty.span
},
VariantData::Unit(..) => unreachable!(),
2017-08-09 07:30:56 +00:00
};
if let Some(snip) = snippet_opt(cx, span) {
diag.span_suggestion(
2017-08-09 07:30:56 +00:00
span,
help_text,
2017-08-09 07:30:56 +00:00
format!("Box<{}>", snip),
2018-09-20 12:38:13 +00:00
Applicability::MaybeIncorrect,
2017-08-09 07:30:56 +00:00
);
return;
}
}
diag.span_help(def.variants[i].span, help_text);
2017-08-09 07:30:56 +00:00
},
);
}
}
}
}
}