new lint: let_arr_const

Author: tesuji

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,97 @@
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::implements_trait;
+use hir::{BindingMode, ExprKind, 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?
+    /// A read-only array should be declared as a `static` item or used tricks
+    /// to made it into `.rodata` section of the compiled file.
+    ///
+    /// ### Known problems
+    /// `let array` puts array on the stack which might make the generated binary file
+    /// bigger and slower.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let a = [0; 64];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let a = *&[0; 64];
+    /// // or
+    /// static A: [u32; 64] = [0; 64];
+    /// ```
+    #[clippy::version = "1.80.0"]
+    pub LET_ARR_CONST,
+    perf,
+    "declare a read-only array on stack"
+}
+
+declare_lint_pass!(LetArrConst => [LET_ARR_CONST]);
+
+impl LateLintPass<'_> for LetArrConst {
+    // should lint on `let array` which non-mut and:
+    // if let repeat:
+    // if let expr: copy
+    // todo: repair clippy::author
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        if let StmtKind::Let(ref local) = stmt.kind
+            && let PatKind::Binding(BindingMode::NONE, _, _name, None) = local.pat.kind
+            && let Some(ref init) = local.init
+            && !init.span.from_expansion()
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let lang_items = cx.tcx.lang_items();
+            let Some(copy_id) = lang_items.copy_trait() else {
+                return;
+            };
+            // `let arr = [<Copy type>; 42];
+            let mut should = false;
+            if let ExprKind::Repeat(ref value, _length) = init.kind {
+                let ty = cx.typeck_results().expr_ty(value);
+                if !implements_trait(cx, ty, copy_id, &[]) {
+                    span_lint_and_help(
+                        cx,
+                        LET_ARR_CONST,
+                        local.span,
+                        "declaring a read-only array on the stack",
+                        None,
+                        "using `static` to push the array to read-only section of program",
+                    );
+                    return;
+                }
+                should = true;
+            }
+            // `let arr = [1, 2, 3, 4];
+            if let ExprKind::Array([ref expr, ..]) = init.kind
+                && let ty = cx.typeck_results().expr_ty(expr)
+                && implements_trait(cx, ty, copy_id, &[])
+            {
+                should = true;
+            }
+
+            if should {
+                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",
+                    "using `static` to push the array to read-only section of program or try",
+                    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`
 }
 

tests/ui/let_arr_const.fixed

@@ -0,0 +1,52 @@
+#![crate_type = "lib"]
+#![warn(clippy::let_arr_const)]
+
+// <https://github.com/rust-lang/rust/issues/73825>.
+pub mod issue_rust_73825 {
+    macro_rules! mac_gen_arr {
+        () => {
+            [0u32; 64]
+        };
+    }
+
+    pub fn do_not() {
+        let _repeat = *&[0; 64];
+        let _arr = *&[0, 1, 2, 3, 4];
+        let _arr = mac_gen_arr!();
+        let _arr = gen_array();
+        let _arr = gen_array_non_copy();
+        {
+            let mut arr = [0; 32];
+            arr[1] = 42;
+        }
+        {
+            let a = String::from("a");
+            let b = String::from("a");
+            let _arr = [a, b];
+        }
+        {
+            let mut arr = [const { String::new() }; 32];
+            arr[1] = "a".to_owned();
+        }
+    }
+
+    const fn gen_array() -> [u32; 42] {
+        unimplemented!()
+    }
+
+    const fn gen_array_non_copy() -> [String; 42] {
+        unimplemented!()
+    }
+
+    pub fn do_it() {
+        // Copy type
+        let _repeat: [i32; 64] = *&[0; 64];
+        let _arr = *&[0, 1, 3, 5, 7, 8];
+        // Non Copy type
+        {
+            let _repeat_const = [const { String::new() }; 32];
+            const EMPTY: String = String::new();
+            let _repeat = [EMPTY; 32];
+        }
+    }
+}

tests/ui/let_arr_const.rs

@@ -1,5 +1,5 @@
 #![crate_type = "lib"]
-// #![warn(clippy::let_arr_const)]
+#![warn(clippy::let_arr_const)]
 
 // <https://github.com/rust-lang/rust/issues/73825>.
 pub mod issue_rust_73825 {

tests/ui/let_arr_const.stderr

@@ -0,0 +1,42 @@
+error: declaring a read-only array on the stack
+  --> tests/ui/let_arr_const.rs:43:34
+   |
+LL |         let _repeat: [i32; 64] = [0; 64];
+   |                                  ^^^^^^^
+   |
+   = note: `-D clippy::let-arr-const` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::let_arr_const)]`
+help: using `static` to push the array to read-only section of program or try
+   |
+LL |         let _repeat: [i32; 64] = *&[0; 64];
+   |                                  ~~~~~~~~~
+
+error: declaring a read-only array on the stack
+  --> tests/ui/let_arr_const.rs:44:20
+   |
+LL |         let _arr = [0, 1, 3, 5, 7, 8];
+   |                    ^^^^^^^^^^^^^^^^^^
+   |
+help: using `static` to push the array to read-only section of program or try
+   |
+LL |         let _arr = *&[0, 1, 3, 5, 7, 8];
+   |                    ~~~~~~~~~~~~~~~~~~~~
+
+error: declaring a read-only array on the stack
+  --> tests/ui/let_arr_const.rs:47:13
+   |
+LL |             let _repeat_const = [const { String::new() }; 32];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: using `static` to push the array to read-only section of program
+
+error: declaring a read-only array on the stack
+  --> tests/ui/let_arr_const.rs:49:13
+   |
+LL |             let _repeat = [EMPTY; 32];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: using `static` to push the array to read-only section of program
+
+error: aborting due to 4 previous errors
+