support Rc

Author: yonip23

clippy_lints/src/arc_new_in_vec_from_elem.rs

@@ -5,7 +5,7 @@ use clippy_utils::macros::{root_macro_call_first_node, MacroCall};
 use rustc_hir::{Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -37,43 +37,46 @@ impl LateLintPass<'_> for ArcNewInVecFromElem {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return; };
 
         if let Some(VecArgs::Repeat(elem, _)) = VecArgs::hir(cx, expr) {
-            if !is_arc_new(cx, elem) {
-                return;
-            }
+            let Some(symbol) = new_reference_call(cx, elem) else { return; };
 
-            yield_lint(cx, &macro_call);
+            yield_lint(cx, symbol, &macro_call);
         }
     }
 }
 
-fn yield_lint(cx: &LateContext<'_>, macro_call: &MacroCall) {
+fn yield_lint(cx: &LateContext<'_>, symbol: Symbol, macro_call: &MacroCall) {
+    let symbol_name = symbol.as_str();
+
     span_lint_and_then(
         cx,
         ARC_NEW_IN_VEC_FROM_ELEM,
         macro_call.span,
-        "calling `Arc::new` in `vec![elem; len]`",
+        &format!("calling `{symbol_name}::new` in `vec![elem; len]`"),
         |diag| {
-            diag.note("each `Arc` will point to the same allocation");
-            diag.help("if this is intentional, consider extracting the `Arc` initialization to a variable");
+            diag.note(format!("each `{symbol_name}` will point to the same allocation"));
+            diag.help(format!(
+                "if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
+            ));
         },
     );
 }
 
-/// Checks whether the given `expr` is a call to `Arc::new`
-fn is_arc_new(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+/// Checks whether the given `expr` is a call to `Arc::new` or `Rc::new`
+fn new_reference_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
     if_chain! {
         if let ExprKind::Call(func, _args) = expr.kind;
         if let ExprKind::Path(ref func_path @ QPath::TypeRelative(ty, _)) = func.kind;
         if let TyKind::Path(ref ty_path) = ty.kind;
         if let Some(def_id) = cx.qpath_res(ty_path, ty.hir_id).opt_def_id();
-        if cx.tcx.is_diagnostic_item(sym::Arc, def_id);
+        if last_path_segment(func_path).ident.name == sym::new;
 
         then {
-            let func_segment = last_path_segment(func_path);
-
-            return func_segment.ident.name == sym::new;
+            return match cx.tcx.get_diagnostic_name(def_id) {
+                Some(symbol) if symbol == sym::Arc || symbol == sym::Rc => Some(symbol),
+                _ => None
+            };
         }
     }
 
-    false
+    None
 }

…arc_new_in_vec_from_elem/complex_case.rs …new_in_vec_from_elem/arc/complex_case.rstests/ui/arc_new_in_vec_from_elem/complex_case.rs renamed to tests/ui/arc_new_in_vec_from_elem/arc/complex_case.rs tests/ui/arc_new_in_vec_from_elem/complex_case.rs renamed to tests/ui/arc_new_in_vec_from_elem/arc/complex_case.rs

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

…new_in_vec_from_elem/complex_case.stderr …in_vec_from_elem/arc/complex_case.stderrtests/ui/arc_new_in_vec_from_elem/complex_case.stderr renamed to tests/ui/arc_new_in_vec_from_elem/arc/complex_case.stderr tests/ui/arc_new_in_vec_from_elem/complex_case.stderr renamed to tests/ui/arc_new_in_vec_from_elem/arc/complex_case.stderr

@@ -0,0 +1,19 @@
+error: calling `Rc::new` in `vec![elem; len]`
+  --> $DIR/complex_case.rs:5:13
+   |
+LL |       let v = vec![
+   |  _____________^
+LL | |         std::rc::Rc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: `-D clippy::arc-new-in-vec-from-elem` implied by `-D warnings`
+   = note: each `Rc` will point to the same allocation
+   = help: if this is intentional, consider extracting the `Rc` initialization to a variable
+
+error: aborting due to previous error
+