Add a new lint

Author: cocodery

CHANGELOG.md

@@ -5279,6 +5279,7 @@ Released 2018-09-13
 [`mem_replace_option_with_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_none
 [`mem_replace_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default
 [`mem_replace_with_uninit`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_uninit
+[`might_panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#might_panic
 [`min_ident_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_ident_chars
 [`min_max`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_max
 [`misaligned_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#misaligned_transmute

clippy_lints/src/declared_lints.rs

@@ -451,6 +451,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::WAKER_CLONE_WAKE_INFO,
     crate::methods::WRONG_SELF_CONVENTION_INFO,
     crate::methods::ZST_OFFSET_INFO,
+    crate::might_panic::MIGHT_PANIC_INFO,
     crate::min_ident_chars::MIN_IDENT_CHARS_INFO,
     crate::minmax::MIN_MAX_INFO,
     crate::misc::SHORT_CIRCUIT_STATEMENT_INFO,

clippy_lints/src/lib.rs

@@ -204,6 +204,7 @@ mod match_result_ok;
 mod matches;
 mod mem_replace;
 mod methods;
+mod might_panic;
 mod min_ident_chars;
 mod minmax;
 mod misc;
@@ -1069,6 +1070,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(iter_without_into_iter::IterWithoutIntoIter));
     store.register_late_pass(|_| Box::new(iter_over_hash_type::IterOverHashType));
     store.register_late_pass(|_| Box::new(impl_hash_with_borrow_str_and_bytes::ImplHashWithBorrowStrBytes));
+    store.register_late_pass(|_| Box::new(might_panic::MightPanic));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/might_panic.rs

@@ -0,0 +1,89 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use rustc_ast::ast::LitKind;
+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
+    /// replace accessing array with an `idx`` by a `get(idx)`.
+    ///
+    /// ### Why is this bad?
+    /// it's easier to locate error where you access array when
+    /// out of boundary; and you can write your error handle to
+    /// solve this problem.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let numbers = &[4, 7, 3];
+        /// let my_number = numbers[5];
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let numbers = &[4, 7, 3];
+    /// let Some(my_number) = numbers.get(5) else {
+    ///     // handle
+    /// };
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub MIGHT_PANIC,
+    style,
+    "use `get()` function if you're not sure whether index is legal"
+}
+
+declare_lint_pass!(MightPanic => [MIGHT_PANIC]);
+
+impl LateLintPass<'_> for MightPanic {
+    fn check_stmt<'tcx>(&mut self, cx: &LateContext<'tcx>, stmt: &hir::Stmt<'tcx>) {
+        // pattern matching an `let` stmt satisfy form like `let x: ty = arr[idx];`
+        if let hir::StmtKind::Local(hir::Local {
+            pat,
+            ty,
+            init,
+            els: _,
+            hir_id: _,
+            span,
+            source: _,
+        }) = &stmt.kind
+            && let hir::PatKind::Binding(_, _, ident, _) = pat.kind
+            && let Some(expr) = init
+            && let hir::ExprKind::Index(arr, idx, _) = &expr.kind
+            && let hir::ExprKind::Path(_) = arr.kind
+            && let hir::ExprKind::Lit(spanned) = idx.kind
+            && let LitKind::Int(v, _) = spanned.node
+        {
+            // get type info string by stmt.local.ty.span
+            // may not have an explict type, it doesn't matter
+            let mut ty_str = String::new();
+            if let Some(hir::Ty {
+                hir_id: _,
+                kind: _,
+                span: ty_span,
+            }) = ty
+                && let Some(snip) = snippet_opt(cx, *ty_span)
+            {
+                ty_str = snip;
+            }
+            let span = *span;
+            span_lint_and_then(
+                cx,
+                MIGHT_PANIC,
+                span,
+                "use `get()` function if you're not sure whether index is legal",
+                |diag| {
+                    if let Some(snip) = snippet_opt(cx, arr.span) {
+                        // format sugg string
+                        let sugg = if ty_str.is_empty() {
+                            format!("let Some({ident}) = {snip}.get({v}) else {{ panic!() }};")
+                        } else {
+                            format!("let Some({ident}): Option<&{ty_str}> = {snip}.get({v}) else {{ panic!() }};")
+                        };
+                        diag.span_suggestion(span, "Try", sugg, Applicability::MachineApplicable);
+                    }
+                },
+            );
+        }
+    }
+}