feat: needless_move lint

An implementation for the lint described in
rust-lang#11721

Author: dnbln

CHANGELOG.md

@@ -5274,6 +5274,7 @@ Released 2018-09-13
 [`needless_late_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_late_init
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_match
+[`needless_move`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_move
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
 [`needless_parens_on_range_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literals

clippy_lints/src/declared_lints.rs

@@ -496,6 +496,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
     crate::needless_if::NEEDLESS_IF_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
+    crate::needless_move::NEEDLESS_MOVE_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_ref_mut::NEEDLESS_PASS_BY_REF_MUT_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,

clippy_lints/src/lib.rs

@@ -234,6 +234,7 @@ mod needless_else;
 mod needless_for_each;
 mod needless_if;
 mod needless_late_init;
+mod needless_move;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_ref_mut;
 mod needless_pass_by_value;
@@ -1066,6 +1067,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(move |_| Box::new(manual_hash_one::ManualHashOne::new(msrv())));
     store.register_late_pass(|_| Box::new(iter_without_into_iter::IterWithoutIntoIter));
+    store.register_late_pass(|_| Box::new(needless_move::NeedlessMove));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

clippy_lints/src/needless_move.rs

@@ -0,0 +1,84 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::DiagnosticExt;
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::UpvarCapture;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Pos};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for closures and `async` blocks where the `move` is not necessary.
+    /// E.g. all the values are captured by value into the closure / `async` block.
+    ///
+    /// ### Why is this bad?
+    /// ?
+    /// ### Example
+    /// ```no_run
+    /// let a = String::new();
+    /// let closure = move || {
+    ///     drop(a);
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let a = String::new();
+    /// let closure = || {
+    ///     drop(a);
+    /// };
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub NEEDLESS_MOVE,
+    pedantic,
+    "checks for needless `move`s on closures / `async` blocks"
+}
+
+declare_lint_pass!(NeedlessMove => [NEEDLESS_MOVE]);
+
+impl NeedlessMove {
+    fn check_closure<'tcx>(
+        &self,
+        cx: &LateContext<'tcx>,
+        expr: &'tcx Expr<'tcx>,
+        closure: &'tcx Closure<'tcx>,
+    ) {
+        let CaptureBy::Value = closure.capture_clause else {
+            return;
+        };
+
+        let captured_places = cx.tcx.closure_captures(closure.def_id);
+        for captured_place in captured_places {
+            if let UpvarCapture::ByRef(_) = captured_place.info.capture_kind {
+                return;
+            }
+        }
+
+        let span_move_kw = unimplemented!();  // FIXME: unsure of where to get the span of the `move` kw from.
+
+        span_lint_and_then(
+            cx,
+            NEEDLESS_MOVE,
+            expr.span,
+            "you seem to use `move`, but the `move` is unnecessary",
+            |diag| {
+                diag.suggest_remove_item(cx, span_move_kw, "Remove the `move`", Applicability::MachineApplicable);
+                diag.note("There are no variables captured by reference, so everything ends up moved anyway");
+            },
+        );
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for NeedlessMove {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        let ExprKind::Closure(closure) = &expr.kind else {
+            return;
+        };
+
+        self.check_closure(cx, expr, closure);
+    }
+}

tests/ui/needless_move.rs

@@ -0,0 +1,102 @@
+#![warn(clippy::needless_move)]
+
+#[derive(Copy, Clone)]
+struct Copy;
+
+struct NonCopy;
+
+fn with_owned<T>(_: T) {}
+fn with_ref<T>(_: &T) {}
+fn with_ref_mut<T>(_: &mut T) {}
+
+fn main() {
+    // doesn't trigger on non-move closures
+    let a = NonCopy;
+    let b = Copy;
+    let closure = || {
+        with_owned(a);
+        with_owned(b);
+    };
+
+    // owned + NonCopy
+    let a = NonCopy;
+    let closure = move || {
+        with_owned(a);
+    };
+
+    // owned + Copy
+    let a = Copy;
+    let closure = move || {
+        with_owned(a);
+    };
+
+    // ref + NonCopy
+    let a = NonCopy;
+    let closure = move || {
+        with_ref(&a);
+    };
+
+    // ref + Copy
+    let a = Copy;
+    let closure = move || {
+        with_ref(&a);
+    };
+
+    // ref mut + NonCopy
+    let mut a = NonCopy;
+    let closure = move || {
+        with_ref_mut(&mut a);
+    };
+
+    // ref mut + Copy
+    let mut a = Copy;
+    let closure = move || {
+        with_ref_mut(&mut a);
+    };
+
+    // with async
+
+    // doesn't trigger if not capturing with `move`
+    let a = NonCopy;
+    let b = Copy;
+    let fut = async {
+        with_owned(a);
+        with_owned(b);
+    };
+
+    // owned + non-copy
+    let a = NonCopy;
+    let fut = async move {
+        with_owned(a);
+    };
+
+    // owned + copy
+    let a = Copy;
+    let fut = async move {
+        with_owned(a);
+    };
+
+    // ref + non-copy
+    let a = NonCopy;
+    let fut = async move {
+        with_ref(&a);
+    };
+
+    // ref + copy
+    let a = Copy;
+    let fut = async move {
+        with_ref(&a);
+    };
+
+    // ref mut + non-copy
+    let mut a = NonCopy;
+    let fut = async move {
+        with_ref_mut(&mut a);
+    };
+
+    // ref mut + copy
+    let mut a = Copy;
+    let fut = async move {
+        with_ref_mut(&mut a);
+    };
+}