fix pr comments

Author: yonip23

clippy_lints/src/arc_new_in_vec_from_slice.rs

@@ -1,19 +1,20 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::higher::VecArgs;
+use clippy_utils::last_path_segment;
 use clippy_utils::macros::{root_macro_call_first_node, MacroCall};
-use clippy_utils::{last_path_segment, match_def_path, paths};
 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;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `Arc::new` calls in vector initialization using the slice macro `vec![elem; len]`
+    /// Checks for `Arc::new` in `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.
+    /// This will create `elem` once and clone it `len` times - doing so with `Arc`
+    /// is a bit misleading, as it will create references to the same pointer, rather
+    /// than different `Arc` instances.
     ///
     /// ### Example
     /// ```rust
@@ -38,41 +39,42 @@ impl LateLintPass<'_> for ArcNewInVecFromSlice {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::Call(func, args) = expr.peel_drop_temps().kind;
-            if let ExprKind::Path(QPath::Resolved(_ty, 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",
-                );
+        if let Some(VecArgs::Repeat(elem, _)) = VecArgs::hir(cx, expr) {
+            if !is_arc_new(elem) {
+                return;
             }
+
+            yield_lint(cx, &macro_call);
         }
     }
 }
 
+fn yield_lint(cx: &LateContext<'_>, macro_call: &MacroCall) {
+    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; };
+/// Checks whether the given `expr` is a call to `Arc::new`
+fn is_arc_new(expr: &Expr<'_>) -> bool {
     if_chain! {
-        if let ExprKind::Call(func, _args) = first_arg.kind;
+        if let ExprKind::Call(func, _args) = expr.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;
 
         then {
-            let func_segment = last_path_segment(func_path);
             let ty_segment = last_path_segment(ty_path);
+            let func_segment = last_path_segment(func_path);
 
             return ty_segment.ident.name == sym::Arc && func_segment.ident.name == sym::new;
         }

tests/ui/arc_new_in_vec_from_slice/do_not_warn.rs renamed to tests/ui/arc_new_in_vec_from_slice/vec_from_elem_but_not_arc.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())];
+}