Add a new lint to check for defining of read-only arrays on stack

CHANGELOG.md

@@ -5435,6 +5435,7 @@ Released 2018-09-13
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
+[`let_arr_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_arr_const
 [`let_underscore_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_drop
 [`let_underscore_future`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_future
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock

clippy_lints/src/declared_lints.rs

@@ -260,6 +260,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::len_zero::COMPARISON_TO_EMPTY_INFO,
     crate::len_zero::LEN_WITHOUT_IS_EMPTY_INFO,
     crate::len_zero::LEN_ZERO_INFO,
+    crate::let_arr_const::LET_ARR_CONST_INFO,
     crate::let_if_seq::USELESS_LET_IF_SEQ_INFO,
     crate::let_underscore::LET_UNDERSCORE_FUTURE_INFO,
     crate::let_underscore::LET_UNDERSCORE_LOCK_INFO,

clippy_lints/src/let_arr_const.rs

@@ -0,0 +1,110 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::{implements_trait, is_type_lang_item};
+use clippy_utils::visitors::is_const_evaluatable;
+use hir::{BindingMode, ExprKind, LangItem, PatKind, Stmt, StmtKind};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for defining of read-only arrays on stack.
+    ///
+    /// ### Why is this bad?
+    /// `let array` puts array on the stack. As as intended, the compiler will
+    /// initialize the array directly on the stack, which might make the
+    /// generated binary bigger and slower.
+    ///
+    /// A read-only array should be defined as a `static` item or used a trick
+    /// to made it into `.rodata` section of the compiled program. The use of
+    /// the trick (`*&<array literal>`) will make rustc static-promote the
+    /// array literal. Which means that the array now lives in the read-only
+    /// section of the generated binary. The downside of the trick is that
+    /// it is non-ergonomic and may not be very clear to readers of the code.
+    ///
+    /// ### Known problems
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let a: [u32; N] = [1, 3, 5, ...];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// let a: [u32; N] = *&[1, 3, 5, ...];
+    /// // or
+    /// static A: [u32; N] = [1, 3, 5, ...];
+    /// ```
+    #[clippy::version = "1.80.0"]
+    pub LET_ARR_CONST,
+    perf,
+    "declare a read-only array on stack"
+}
+
+declare_lint_pass!(LetArrConst => [LET_ARR_CONST]);
+
+// FIXME: See also LARGE_CONST_ARRAYS, LARGE_STACK_ARRAYS.
+impl<'tcx> LateLintPass<'tcx> for LetArrConst {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        // let pat: ty = init;
+        if let StmtKind::Let(local) = stmt.kind
+            && let PatKind::Binding(BindingMode::NONE, _, _name, None) = local.pat.kind
+            && let Some(init) = local.init
+            && !init.span.from_expansion()
+        {
+            // LLVM optimizes the load of 16 byte as a single `mov`.
+            // Bigger values make more `mov` instructions generated.
+            // While changing code as this lint suggests, it becomes
+            // a single load (`lea`) of an address in `.rodata`.
+            const STACK_THRESHOLD: u64 = 16;
+            // lint only `if size_of(init) > STACK_THRESHOLD`
+            let ty = cx.typeck_results().expr_ty(init);
+            if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty))
+                && let size = layout.layout.size()
+                && size.bytes() <= STACK_THRESHOLD
+            {
+                return;
+            }
+
+            let mut applicability = Applicability::MachineApplicable;
+            let lang_items = cx.tcx.lang_items();
+            let Some(copy_id) = lang_items.copy_trait() else {
+                return;
+            };
+
+            // if init is [<Copy type>; N]
+            if let ExprKind::Repeat(..) = init.kind {
+                // `init` optimized as the same code.
+                return;
+            }
+
+            // if init is [1, 2, 3, ...]
+            let ExprKind::Array(items @ [ref expr, ..]) = init.kind else {
+                return;
+            };
+
+            let ty = cx.typeck_results().expr_ty(expr);
+            // skip MaybeUnint and ManuallyDrop types
+            if is_type_lang_item(cx, ty, LangItem::MaybeUninit) || is_type_lang_item(cx, ty, LangItem::ManuallyDrop) {
+                return;
+            }
+
+            if implements_trait(cx, ty, copy_id, &[]) && items.iter().all(|expr| is_const_evaluatable(cx, expr)) {
+                let msg = "using `static` to push the array to read-only section of program or try";
+                let snippet = snippet_with_applicability(cx, init.span, "_", &mut applicability);
+                let sugg = format!("*&{snippet}");
+                span_lint_and_sugg(
+                    cx,
+                    LET_ARR_CONST,
+                    init.span,
+                    "declaring a read-only array on the stack",
+                    msg,
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+}

clippy_lints/src/lib.rs

@@ -187,6 +187,7 @@ mod large_stack_arrays;
 mod large_stack_frames;
 mod legacy_numeric_constants;
 mod len_zero;
+mod let_arr_const;
 mod let_if_seq;
 mod let_underscore;
 mod let_with_type_underscore;
@@ -1165,6 +1166,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
             ..Default::default()
         })
     });
+    store.register_late_pass(|_| Box::new(let_arr_const::LetArrConst));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/methods/option_as_ref_deref.rs

@@ -20,6 +20,16 @@ pub(super) fn check(
     is_mut: bool,
     msrv: &Msrv,
 ) {
+    static DEREF_ALIASES: [&[&str]; 7] = [
+        &paths::CSTRING_AS_C_STR,
+        &paths::OS_STRING_AS_OS_STR,
+        &paths::PATH_BUF_AS_PATH,
+        &paths::STRING_AS_STR,
+        &paths::STRING_AS_MUT_STR,
+        &paths::VEC_AS_SLICE,
+        &paths::VEC_AS_MUT_SLICE,
+    ];
+
     if !msrv.meets(msrvs::OPTION_AS_DEREF) {
         return;
     }
@@ -31,24 +41,14 @@ pub(super) fn check(
         return;
     }
 
-    let deref_aliases: [&[&str]; 7] = [
-        &paths::CSTRING_AS_C_STR,
-        &paths::OS_STRING_AS_OS_STR,
-        &paths::PATH_BUF_AS_PATH,
-        &paths::STRING_AS_STR,
-        &paths::STRING_AS_MUT_STR,
-        &paths::VEC_AS_SLICE,
-        &paths::VEC_AS_MUT_SLICE,
-    ];
-
     let is_deref = match map_arg.kind {
         hir::ExprKind::Path(ref expr_qpath) => {
             cx.qpath_res(expr_qpath, map_arg.hir_id)
                 .opt_def_id()
                 .map_or(false, |fun_def_id| {
                     cx.tcx.is_diagnostic_item(sym::deref_method, fun_def_id)
                         || cx.tcx.is_diagnostic_item(sym::deref_mut_method, fun_def_id)
-                        || deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
+                        || DEREF_ALIASES.iter().any(|path| match_def_path(cx, fun_def_id, path))
                 })
         },
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
@@ -69,7 +69,7 @@ pub(super) fn check(
                         let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
                         cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
                             || cx.tcx.is_diagnostic_item(sym::deref_mut_method, method_did)
-                            || deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
+                            || DEREF_ALIASES.iter().any(|path| match_def_path(cx, method_did, path))
                     } else {
                         false
                     }

clippy_lints/src/reference.rs

@@ -48,6 +48,8 @@ impl EarlyLintPass for DerefAddrOf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
         if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind
             && let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind
+            // NOTE(tesuji): without it, this lints conflicts with `let-arr-const` lint.
+            && !matches!(addrof_target.kind, ExprKind::Array(_) | ExprKind::Repeat(..))
             && deref_target.span.eq_ctxt(e.span)
             && !addrof_target.span.from_expansion()
         {

lintcheck/src/main.rs

@@ -855,7 +855,7 @@ fn clippy_project_root() -> &'static Path {
 
 #[test]
 fn lintcheck_test() {
-    let args = [
+    let args = *&[
         "run",
         "--target-dir",
         "lintcheck/target",

tests/ui-toml/disallowed_names_append/disallowed_names.rs

@@ -1,4 +1,5 @@
-#[warn(clippy::disallowed_names)]
+#![warn(clippy::disallowed_names)]
+#![allow(clippy::let_arr_const)]
 
 fn main() {
     // `foo` is part of the default configuration

tests/ui-toml/disallowed_names_append/disallowed_names.stderr

@@ -1,5 +1,5 @@
 error: use of a disallowed/placeholder name `foo`
-  --> tests/ui-toml/disallowed_names_append/disallowed_names.rs:5:9
+  --> tests/ui-toml/disallowed_names_append/disallowed_names.rs:6:9
    |
 LL |     let foo = "bar";
    |         ^^^
@@ -8,7 +8,7 @@ LL |     let foo = "bar";
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_names)]`
 
 error: use of a disallowed/placeholder name `ducks`
-  --> tests/ui-toml/disallowed_names_append/disallowed_names.rs:7:9
+  --> tests/ui-toml/disallowed_names_append/disallowed_names.rs:8:9
    |
 LL |     let ducks = ["quack", "quack"];
    |         ^^^^^

tests/ui-toml/disallowed_names_replace/disallowed_names.rs

@@ -1,4 +1,5 @@
-#[warn(clippy::disallowed_names)]
+#![warn(clippy::disallowed_names)]
+#![allow(clippy::let_arr_const)]
 
 fn main() {
     // `foo` is part of the default configuration

tests/ui-toml/disallowed_names_replace/disallowed_names.stderr

@@ -1,5 +1,5 @@
 error: use of a disallowed/placeholder name `ducks`
-  --> tests/ui-toml/disallowed_names_replace/disallowed_names.rs:7:9
+  --> tests/ui-toml/disallowed_names_replace/disallowed_names.rs:8:9
    |
 LL |     let ducks = ["quack", "quack"];
    |         ^^^^^

tests/ui-toml/large_futures/large_futures.fixed

@@ -1,4 +1,5 @@
 #![warn(clippy::large_futures)]
+#![allow(clippy::let_arr_const)]
 
 fn main() {}
 

tests/ui-toml/large_futures/large_futures.rs

@@ -1,4 +1,5 @@
 #![warn(clippy::large_futures)]
+#![allow(clippy::let_arr_const)]
 
 fn main() {}
 

tests/ui-toml/large_futures/large_futures.stderr

@@ -1,5 +1,5 @@
 error: large future with a size of 1026 bytes
-  --> tests/ui-toml/large_futures/large_futures.rs:18:5
+  --> tests/ui-toml/large_futures/large_futures.rs:19:5
    |
 LL |     should_warn().await;
    |     ^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(should_warn())`

tests/ui-toml/too_large_for_stack/useless_vec.fixed

@@ -1,4 +1,5 @@
 #![warn(clippy::useless_vec)]
+#![allow(clippy::let_arr_const)]
 
 fn main() {
     let x = [0u8; 500];

tests/ui-toml/too_large_for_stack/useless_vec.rs

@@ -1,4 +1,5 @@
 #![warn(clippy::useless_vec)]
+#![allow(clippy::let_arr_const)]
 
 fn main() {
     let x = vec![0u8; 500];

tests/ui-toml/too_large_for_stack/useless_vec.stderr

@@ -1,5 +1,5 @@
 error: useless use of `vec!`
-  --> tests/ui-toml/too_large_for_stack/useless_vec.rs:4:13
+  --> tests/ui-toml/too_large_for_stack/useless_vec.rs:5:13
    |
 LL |     let x = vec![0u8; 500];
    |             ^^^^^^^^^^^^^^ help: you can use an array directly: `[0u8; 500]`

tests/ui/crashes/ice-12253.rs

@@ -1,4 +1,4 @@
-#[allow(overflowing_literals, unconditional_panic, clippy::no_effect)]
+#[allow(overflowing_literals, unconditional_panic, clippy::no_effect, clippy::let_arr_const)]
 fn main() {
     let arr: [i32; 5] = [0; 5];
     arr[0xfffffe7ffffffffffffffffffffffff];

tests/ui/crashes/ice-5389.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::explicit_counter_loop)]
+#![allow(clippy::explicit_counter_loop, clippy::let_arr_const)]
 
 fn main() {
     let v = vec![1, 2, 3];

tests/ui/default_numeric_fallback_f64.fixed

@@ -9,7 +9,8 @@
     clippy::branches_sharing_code,
     clippy::match_single_binding,
     clippy::let_unit_value,
-    clippy::let_with_type_underscore
+    clippy::let_with_type_underscore,
+    clippy::let_arr_const
 )]
 
 extern crate proc_macros;

tests/ui/default_numeric_fallback_f64.rs

@@ -9,7 +9,8 @@
     clippy::branches_sharing_code,
     clippy::match_single_binding,
     clippy::let_unit_value,
-    clippy::let_with_type_underscore
+    clippy::let_with_type_underscore,
+    clippy::let_arr_const
 )]
 
 extern crate proc_macros;