Move lint to methods pass

This gives us things like checking if we are in a macro

Author: rspencer01

clippy_lints/src/declared_lints.rs

@@ -320,7 +320,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_unwrap_or_default::MANUAL_UNWRAP_OR_DEFAULT_INFO,
     crate::map_unit_fn::OPTION_MAP_UNIT_FN_INFO,
     crate::map_unit_fn::RESULT_MAP_UNIT_FN_INFO,
-    crate::map_with_unused_argument_over_ranges::MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES_INFO,
     crate::match_result_ok::MATCH_RESULT_OK_INFO,
     crate::matches::COLLAPSIBLE_MATCH_INFO,
     crate::matches::INFALLIBLE_DESTRUCTURING_MATCH_INFO,
@@ -419,6 +418,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::MAP_FLATTEN_INFO,
     crate::methods::MAP_IDENTITY_INFO,
     crate::methods::MAP_UNWRAP_OR_INFO,
+    crate::methods::MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES_INFO,
     crate::methods::MUT_MUTEX_LOCK_INFO,
     crate::methods::NAIVE_BYTECOUNT_INFO,
     crate::methods::NEEDLESS_CHARACTER_ITERATION_INFO,

clippy_lints/src/lib.rs

@@ -217,7 +217,6 @@ mod manual_string_new;
 mod manual_strip;
 mod manual_unwrap_or_default;
 mod map_unit_fn;
-mod map_with_unused_argument_over_ranges;
 mod match_result_ok;
 mod matches;
 mod mem_replace;
@@ -1175,9 +1174,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(string_patterns::StringPatterns::new(msrv())));
     store.register_early_pass(|| Box::new(field_scoped_visibility_modifiers::FieldScopedVisibilityModifiers));
     store.register_late_pass(|_| Box::new(set_contains_or_insert::HashsetInsertAfterContains));
-    store.register_late_pass(move |_| {
-        Box::new(map_with_unused_argument_over_ranges::MapWithUnusedArgumentOverRanges::new(msrv()))
-    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/map_with_unused_argument_over_ranges.rs renamed to clippy_lints/src/methods/map_with_unused_argument_over_ranges.rs

@@ -90,32 +90,29 @@ fn extract_count_with_applicability(
     None
 }
 
-impl LateLintPass<'_> for MapWithUnusedArgumentOverRanges {
-    fn check_expr(&mut self, cx: &LateContext<'_>, ex: &Expr<'_>) {
-        if !self.msrv.meets(msrvs::REPEAT_WITH) {
-            return;
-        }
-        let mut applicability = Applicability::MaybeIncorrect;
-        if let ExprKind::MethodCall(path, receiver, [map_arg_expr], _call_span) = ex.kind
-            && path.ident.name == rustc_span::sym::map
-            && let Some(range) = higher::Range::hir(receiver)
-            && let ExprKind::Closure(Closure { body, .. }) = map_arg_expr.kind
-            && let Body { params: [param], .. } = cx.tcx.hir().body(*body)
-            && matches!(param.pat.kind, PatKind::Wild)
-            && let Some(count) = extract_count_with_applicability(cx, range, &mut applicability)
-        {
-            let snippet = snippet_with_applicability(cx, map_arg_expr.span, "|| { ... }", &mut applicability)
-                .replacen("|_|", "||", 1);
-            span_lint_and_sugg(
-                cx,
-                MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
-                ex.span,
-                "map of a trivial closure (not dependent on parameter) over a range",
-                "use",
-                format!("std::iter::repeat_with({snippet}).take({count})"),
-                applicability,
-            );
-        }
+pub(super) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>, msrv: &Msrv) {
+    if !msrv.meets(msrvs::REPEAT_WITH) {
+        return;
+    }
+    let mut applicability = Applicability::MaybeIncorrect;
+    if let ExprKind::MethodCall(path, receiver, [map_arg_expr], _call_span) = ex.kind
+        && path.ident.name == rustc_span::sym::map
+        && let Some(range) = higher::Range::hir(receiver)
+        && let ExprKind::Closure(Closure { body, .. }) = map_arg_expr.kind
+        && let Body { params: [param], .. } = cx.tcx.hir().body(*body)
+        && matches!(param.pat.kind, PatKind::Wild)
+        && let Some(count) = extract_count_with_applicability(cx, range, &mut applicability)
+    {
+        let snippet = snippet_with_applicability(cx, map_arg_expr.span, "|| { ... }", &mut applicability)
+            .replacen("|_|", "||", 1);
+        span_lint_and_sugg(
+            cx,
+            MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+            ex.span,
+            "map of a trivial closure (not dependent on parameter) over a range",
+            "use",
+            format!("std::iter::repeat_with({snippet}).take({count})"),
+            applicability,
+        );
     }
-    extract_msrv_attr!(LateContext);
 }

clippy_lints/src/methods/mod.rs

@@ -66,6 +66,7 @@ mod map_err_ignore;
 mod map_flatten;
 mod map_identity;
 mod map_unwrap_or;
+mod map_with_unused_argument_over_ranges;
 mod mut_mutex_lock;
 mod needless_character_iteration;
 mod needless_collect;
@@ -4127,6 +4128,32 @@ declare_clippy_lint! {
     "use of `map` returning the original item"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `Iterator::map` over ranges without using the parameter which
+    /// could be more clearly expressed using `std::iter::repeat_with(...).take(...)`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It expresses the intent more clearly to `take` the correct number of times
+    /// from a generating function than to apply a closure to each number in a
+    /// range only to discard them.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let random_numbers : Vec<_> = (0..10).map(|_| { 3 + 1 }).collect();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let f : Vec<_> = std::iter::repeat_with(|| { 3 + 1 }).take(10).collect();
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
+    style,
+    "map of a trivial closure (not dependent on parameter) over a range"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -4294,6 +4321,7 @@ impl_lint_pass!(Methods => [
     NEEDLESS_CHARACTER_ITERATION,
     MANUAL_INSPECT,
     UNNECESSARY_MIN_OR_MAX,
+    MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4769,6 +4797,7 @@ impl Methods {
                     if name == "map" {
                         unused_enumerate_index::check(cx, expr, recv, m_arg);
                         map_clone::check(cx, expr, recv, m_arg, &self.msrv);
+                        map_with_unused_argument_over_ranges::check(cx, expr, recv, m_arg, &self.msrv);
                         match method_call(recv) {
                             Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) => {
                                 iter_kv_map::check(cx, map_name, expr, recv2, m_arg, &self.msrv);

tests/ui/map_with_unused_argument_over_ranges.fixed

@@ -11,7 +11,7 @@ fn do_something_interesting(x: usize, y: usize) -> usize {
 
 macro_rules! gen {
     () => {
-        std::iter::repeat_with(|| do_something()).take(10);
+        (0..10).map(|_| do_something());
     };
 }
 

tests/ui/map_with_unused_argument_over_ranges.stderr

@@ -78,17 +78,6 @@ error: map of a trivial closure (not dependent on parameter) over a range
 LL |     (2..=upper_fn()).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `std::iter::repeat_with(|| do_something()).take(upper_fn() + 3)`
 
-error: map of a trivial closure (not dependent on parameter) over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:14:9
-   |
-LL |         (0..10).map(|_| do_something());
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `std::iter::repeat_with(|| do_something()).take(10)`
-...
-LL |     gen!();
-   |     ------ in this macro invocation
-   |
-   = note: this error originates in the macro `gen` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: map of a trivial closure (not dependent on parameter) over a range
   --> tests/ui/map_with_unused_argument_over_ranges.rs:41:5
    |
@@ -101,5 +90,5 @@ error: map of a trivial closure (not dependent on parameter) over a range
 LL |     (0..10).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `std::iter::repeat_with(|| do_something()).take(10)`
 
-error: aborting due to 14 previous errors
+error: aborting due to 13 previous errors