src/tools/clippy/clippy_lints/src/large_const_arrays.rs

   1 use clippy_utils::diagnostics::span_lint_and_then;
   2 use if_chain::if_chain;
   3 use rustc_errors::Applicability;
   4 use rustc_hir::{Item, ItemKind};
   5 use rustc_lint::{LateContext, LateLintPass};
   6 use rustc_middle::ty::layout::LayoutOf;
   7 use rustc_middle::ty::{self, ConstKind};
   8 use rustc_session::{declare_tool_lint, impl_lint_pass};
   9 use rustc_span::{BytePos, Pos, Span};
  10 use rustc_typeck::hir_ty_to_ty;
  11
  12 declare_clippy_lint! {
  13     /// ### What it does
  14     /// Checks for large `const` arrays that should
  15     /// be defined as `static` instead.
  16     ///
  17     /// ### Why is this bad?
  18     /// Performance: const variables are inlined upon use.
  19     /// Static items result in only one instance and has a fixed location in memory.
  20     ///
  21     /// ### Example
  22     /// ```rust,ignore
  23     /// pub const a = [0u32; 1_000_000];
  24     /// ```
  25     ///
  26     /// Use instead:
  27     /// ```rust,ignore
  28     /// pub static a = [0u32; 1_000_000];
  29     /// ```
  30     #[clippy::version = "1.44.0"]
  31     pub LARGE_CONST_ARRAYS,
  32     perf,
  33     "large non-scalar const array may cause performance overhead"
  34 }
  35
  36 pub struct LargeConstArrays {
  37     maximum_allowed_size: u64,
  38 }
  39
  40 impl LargeConstArrays {
  41     #[must_use]
  42     pub fn new(maximum_allowed_size: u64) -> Self {
  43         Self { maximum_allowed_size }
  44     }
  45 }
  46
  47 impl_lint_pass!(LargeConstArrays => [LARGE_CONST_ARRAYS]);
  48
  49 impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
  50     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
  51         if_chain! {
  52             if !item.span.from_expansion();
  53             if let ItemKind::Const(hir_ty, _) = &item.kind;
  54             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
  55             if let ty::Array(element_type, cst) = ty.kind();
  56             if let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind();
  57             if let Ok(element_count) = element_count.try_to_machine_usize(cx.tcx);
  58             if let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes());
  59             if self.maximum_allowed_size < element_count * element_size;
  60
  61             then {
  62                 let hi_pos = item.ident.span.lo() - BytePos::from_usize(1);
  63                 let sugg_span = Span::new(
  64                     hi_pos - BytePos::from_usize("const".len()),
  65                     hi_pos,
  66                     item.span.ctxt(),
  67                     item.span.parent(),
  68                 );
  69                 span_lint_and_then(
  70                     cx,
  71                     LARGE_CONST_ARRAYS,
  72                     item.span,
  73                     "large array defined as const",
  74                     |diag| {
  75                         diag.span_suggestion(
  76                             sugg_span,
  77                             "make this a static item",
  78                             "static",
  79                             Applicability::MachineApplicable,
  80                         );
  81                     }
  82                 );
  83             }
  84         }
  85     }
  86 }