add arc_new_in_vec_from_slice lint

Author: yonip23

CHANGELOG.md

@@ -3278,6 +3278,7 @@ Released 2018-09-13
 [`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
+[`arc_in_vec_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#arc_in_vec_init
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
 [`assign_op_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_op_pattern

clippy_lints/src/arc_new_in_vec_from_slice.rs

@@ -0,0 +1,79 @@
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::macros::{MacroCall, root_macro_call_first_node};
+use clippy_utils::{last_path_segment, match_def_path, paths};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `Arc::new` calls in vector initialization using the slice macro `vec![elem; len]`
+    ///
+    /// ### Why is this bad?
+    /// This vector initialization creates `elem` once and clones it `len` times - doing so with `Arc`
+    /// is a bit missleading, because the vector will contain references to the same pointer, although
+    /// it can look like it'll contain different `Arc` instances.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let v = vec![std::sync::Arc::new("some data".to_string()); 100];
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let data = std::sync::Arc::new("some data".to_string());
+    /// let v = vec![data; 100];
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub ARC_NEW_IN_VEC_FROM_SLICE,
+    suspicious,
+    "default lint description"
+}
+declare_lint_pass!(ArcNewInVecFromSlice => [ARC_NEW_IN_VEC_FROM_SLICE]);
+
+impl LateLintPass<'_> for ArcNewInVecFromSlice {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return; };
+        if !macro_is_vec(cx, &macro_call) { return; }
+
+        if_chain! {
+            if let ExprKind::Call(func, args) = expr.peel_drop_temps().kind;
+            if let ExprKind::Path(QPath::Resolved(_ty, ref path)) = func.kind;
+            if let Some(did) = path.res.opt_def_id();
+            then {
+                if !(match_def_path(cx, did, &paths::VEC_FROM_ELEM) && first_arg_is_arc_new(args)) { return; }
+
+                span_lint_and_help(
+                    cx,
+                    ARC_NEW_IN_VEC_FROM_SLICE,
+                    macro_call.span,
+                    "calling `Arc::new` in `vec![elem; len]`",
+                    None,
+                    "consider extracting `Arc` initialization to a variable",
+                );
+            }
+        }
+    }
+}
+
+fn macro_is_vec(cx: &LateContext<'_>, macro_call: &MacroCall) -> bool {
+    cx.tcx.is_diagnostic_item(sym::vec_macro, macro_call.def_id)
+}
+
+fn first_arg_is_arc_new(args: &[Expr<'_>]) -> bool {
+    let Some(first_arg) = args.get(0) else { return false; };
+    if_chain! {
+        if let ExprKind::Call(func, _args) = first_arg.kind;
+        if let ExprKind::Path(ref func_path) = func.kind;
+        if let ExprKind::Path(QPath::TypeRelative(ty, _)) =  func.kind;
+        if let TyKind::Path(ref ty_path) = ty.kind;
+        let func_segment = last_path_segment(func_path);
+        let ty_segment = last_path_segment(ty_path);
+
+        then {
+            return ty_segment.ident.name.as_str() == "Arc" && func_segment.ident.name.as_str() == "new";
+        }
+    }
+
+    false
+}

clippy_lints/src/lib.register_all.rs

@@ -5,6 +5,7 @@
 store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
     LintId::of(approx_const::APPROX_CONSTANT),
+    LintId::of(arc_new_in_vec_from_slice::ARC_NEW_IN_VEC_FROM_SLICE),
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
     LintId::of(assign_ops::ASSIGN_OP_PATTERN),
     LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),

clippy_lints/src/lib.register_lints.rs

@@ -35,6 +35,7 @@ store.register_lints(&[
     utils::internal_lints::UNNECESSARY_SYMBOL_STR,
     absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
     approx_const::APPROX_CONSTANT,
+    arc_new_in_vec_from_slice::ARC_NEW_IN_VEC_FROM_SLICE,
     arithmetic::FLOAT_ARITHMETIC,
     arithmetic::INTEGER_ARITHMETIC,
     as_conversions::AS_CONVERSIONS,

clippy_lints/src/lib.register_suspicious.rs

@@ -3,6 +3,7 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
+    LintId::of(arc_new_in_vec_from_slice::ARC_NEW_IN_VEC_FROM_SLICE),
     LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),

clippy_lints/src/lib.rs

@@ -166,6 +166,7 @@ mod utils;
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absurd_extreme_comparisons;
 mod approx_const;
+mod arc_new_in_vec_from_slice;
 mod arithmetic;
 mod as_conversions;
 mod asm_syntax;
@@ -887,6 +888,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(bytes_count_to_len::BytesCountToLen));
     let max_include_file_size = conf.max_include_file_size;
     store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
+    store.register_late_pass(|| Box::new(arc_new_in_vec_from_slice::ArcNewInVecFromSlice));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

tests/ui/arc_new_in_vec_from_slice/complex_case.rs

@@ -0,0 +1,10 @@
+#![warn(clippy::arc_new_in_vec_from_slice)]
+use std::sync::Mutex;
+
+fn main() {
+    let v = vec![std::sync::Arc::new(Mutex::new({
+        let x = 1;
+        dbg!(x);
+        x
+    })); 2];
+}

tests/ui/arc_new_in_vec_from_slice/complex_case.stderr

@@ -0,0 +1,16 @@
+error: calling `Arc::new` in `vec![elem; len]`
+  --> $DIR/complex_case.rs:5:13
+   |
+LL |       let v = vec![std::sync::Arc::new(Mutex::new({
+   |  _____________^
+LL | |         let x = 1;
+LL | |         dbg!(x);
+LL | |         x
+LL | |     })); 2];
+   | |___________^
+   |
+   = note: `-D clippy::arc-new-in-vec-from-slice` implied by `-D warnings`
+   = help: consider extracting `Arc` initialization to a variable
+
+error: aborting due to previous error
+

tests/ui/arc_new_in_vec_from_slice/do_not_warn.rs

@@ -0,0 +1,12 @@
+#![warn(clippy::arc_new_in_vec_from_slice)]
+use std::sync::{Mutex, Arc};
+
+fn main() {
+    let v = vec![String::new(); 2];
+    let v1 = vec![1; 2];
+    let v2 = vec![Box::new(std::sync::Arc::new({
+        let y = 3;
+        dbg!(y);
+        y
+    })); 2];
+}

tests/ui/arc_new_in_vec_from_slice/simple_case.rs

@@ -0,0 +1,6 @@
+#![warn(clippy::arc_new_in_vec_from_slice)]
+use std::sync::Arc;
+
+fn main() {
+    let v = vec![Arc::new("x".to_string()); 2];
+}