New lint: copy_then_borrow_mut

Author: samueltardieu

CHANGELOG.md

@@ -5539,6 +5539,7 @@ Released 2018-09-13
 [`const_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#const_is_empty
 [`const_static_lifetime`]: https://rust-lang.github.io/rust-clippy/master/index.html#const_static_lifetime
 [`copy_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_iterator
+[`copy_then_borrow_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_then_borrow_mut
 [`crate_in_macro_def`]: https://rust-lang.github.io/rust-clippy/master/index.html#crate_in_macro_def
 [`create_dir`]: https://rust-lang.github.io/rust-clippy/master/index.html#create_dir
 [`crosspointer_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute
@@ -6343,6 +6344,7 @@ Released 2018-09-13
 [`avoid-breaking-exported-api`]: https://doc.rust-lang.org/clippy/lint_configuration.html#avoid-breaking-exported-api
 [`await-holding-invalid-types`]: https://doc.rust-lang.org/clippy/lint_configuration.html#await-holding-invalid-types
 [`cargo-ignore-publish`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cargo-ignore-publish
+[`check-copy-then-borrow-mut-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-copy-then-borrow-mut-in-tests
 [`check-incompatible-msrv-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-incompatible-msrv-in-tests
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`cognitive-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cognitive-complexity-threshold

book/src/lint_configuration.md

@@ -415,6 +415,16 @@ For internal testing only, ignores the current `publish` settings in the Cargo m
 * [`cargo_common_metadata`](https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata)
 
 
+## `check-copy-then-borrow-mut-in-tests`
+Whether to search for mutable borrows of freshly copied data in tests.
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`copy_then_borrow_mut`](https://rust-lang.github.io/rust-clippy/master/index.html#copy_then_borrow_mut)
+
+
 ## `check-incompatible-msrv-in-tests`
 Whether to check MSRV compatibility in `#[test]` and `#[cfg(test)]` code.
 

clippy_config/src/conf.rs

@@ -464,6 +464,9 @@ define_Conf! {
     /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     #[lints(cargo_common_metadata)]
     cargo_ignore_publish: bool = false,
+    /// Whether to search for mutable borrows of freshly copied data in tests.
+    #[lints(copy_then_borrow_mut)]
+    check_copy_then_borrow_mut_in_tests: bool = true,
     /// Whether to check MSRV compatibility in `#[test]` and `#[cfg(test)]` code.
     #[lints(incompatible_msrv)]
     check_incompatible_msrv_in_tests: bool = false,

clippy_lints/src/copy_then_borrow_mut.rs

@@ -0,0 +1,114 @@
+use clippy_config::Conf;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::is_copy;
+use clippy_utils::{get_enclosing_block, is_in_test, path_to_local};
+use rustc_ast::BindingMode;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, BorrowKind, Expr, ExprKind, Mutability, Node, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::impl_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for mutable reference on a freshly copied variable due to
+    /// the use of a block to return an value implementing `Copy`.
+    ///
+    /// ### Why is this bad?
+    /// Using a block will make a copy of the block result if its type
+    /// implements `Copy`. This might be an indication of a failed attempt
+    /// to borrow a variable, or part of a variable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # unsafe fn unsafe_func(_: &mut i32) {}
+    /// let mut a = 10;
+    /// let double_a_ref = &mut unsafe { // Unsafe block needed to call `unsafe_func`
+    ///    unsafe_func(&mut a);
+    ///    a
+    /// };
+    /// ```
+    /// If you intend to take a reference on `a` and you need the block,
+    /// create the reference inside the block instead:
+    /// ```no_run
+    /// # unsafe fn unsafe_func(_: &mut i32) {}
+    /// let mut a = 10;
+    /// let double_a_ref = unsafe { // Unsafe block needed to call `unsafe_func`
+    ///    unsafe_func(&mut a);
+    ///    &mut a
+    /// };
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub COPY_THEN_BORROW_MUT,
+    suspicious,
+    "mutable borrow of a data which was just copied"
+}
+
+pub struct CopyThenBorrowMut {
+    check_in_tests: bool,
+}
+
+impl CopyThenBorrowMut {
+    pub const fn new(conf: &Conf) -> Self {
+        Self {
+            check_in_tests: conf.check_copy_then_borrow_mut_in_tests,
+        }
+    }
+}
+
+impl_lint_pass!(CopyThenBorrowMut => [COPY_THEN_BORROW_MUT]);
+
+impl LateLintPass<'_> for CopyThenBorrowMut {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if !expr.span.from_expansion()
+            && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, sub_expr) = expr.kind
+            && let ExprKind::Block(block, _) = sub_expr.kind
+            && !block.targeted_by_break
+            && block.span.eq_ctxt(expr.span)
+            && let Some(block_expr) = block.expr
+            && let block_ty = cx.typeck_results().expr_ty_adjusted(block_expr)
+            && is_copy(cx, block_ty)
+            && is_expr_mutable_outside_block(cx, block_expr, block)
+            && (self.check_in_tests || !is_in_test(cx.tcx, expr.hir_id))
+        {
+            span_lint_and_then(
+                cx,
+                COPY_THEN_BORROW_MUT,
+                expr.span,
+                "mutable borrow of a value which was just copied",
+                |diag| {
+                    diag.multipart_suggestion(
+                        "try building the reference inside the block",
+                        vec![
+                            (expr.span.until(block.span), String::new()),
+                            (block_expr.span.shrink_to_lo(), String::from("&mut ")),
+                        ],
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+}
+
+/// Checks if `expr` denotes a mutable variable defined outside `block`, or, recursively, a field or
+/// index of such a variable.
+fn is_expr_mutable_outside_block(cx: &LateContext<'_>, mut expr: &Expr<'_>, block: &Block<'_>) -> bool {
+    while let ExprKind::Field(base, _) | ExprKind::Index(base, _, _) = expr.kind {
+        expr = base;
+    }
+    if let Some(mut hir_id) = path_to_local(expr)
+        && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+        && matches!(pat.kind, PatKind::Binding(BindingMode::MUT, ..))
+    {
+        // Scan enclosing blocks until we find `block`, or we loop or can't find
+        // blocks anymore.
+        loop {
+            match get_enclosing_block(cx, hir_id).map(|b| b.hir_id) {
+                Some(block_id) if block_id == block.hir_id => return false,
+                Some(block_id) if block_id != hir_id => hir_id = block_id,
+                _ => return true,
+            }
+        }
+    }
+    false
+}

clippy_lints/src/declared_lints.rs

@@ -113,6 +113,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::copies::IF_SAME_THEN_ELSE_INFO,
     crate::copies::SAME_FUNCTIONS_IN_IF_CONDITION_INFO,
     crate::copy_iterator::COPY_ITERATOR_INFO,
+    crate::copy_then_borrow_mut::COPY_THEN_BORROW_MUT_INFO,
     crate::crate_in_macro_def::CRATE_IN_MACRO_DEF_INFO,
     crate::create_dir::CREATE_DIR_INFO,
     crate::dbg_macro::DBG_MACRO_INFO,

clippy_lints/src/lib.rs

@@ -103,6 +103,7 @@ mod collection_is_never_read;
 mod comparison_chain;
 mod copies;
 mod copy_iterator;
+mod copy_then_borrow_mut;
 mod crate_in_macro_def;
 mod create_dir;
 mod dbg_macro;
@@ -984,5 +985,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(non_std_lazy_statics::NonStdLazyStatic::new(conf)));
     store.register_late_pass(|_| Box::new(manual_option_as_slice::ManualOptionAsSlice::new(conf)));
     store.register_late_pass(|_| Box::new(single_option_map::SingleOptionMap));
+    store.register_late_pass(|_| Box::new(copy_then_borrow_mut::CopyThenBorrowMut::new(conf)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

tests/ui-toml/copy_then_borrow_mut/clippy.toml

@@ -0,0 +1 @@
+check-copy-then-borrow-mut-in-tests = false

tests/ui-toml/copy_then_borrow_mut/copy_then_borrow_mut.fixed

@@ -0,0 +1,10 @@
+#[test]
+fn in_test() {
+    let mut a = [10; 2];
+    let _ = &mut { a }; // Do not lint
+}
+
+fn main() {
+    let mut a = [10; 2];
+    let _ = { &mut a }; //~ ERROR: mutable borrow
+}

tests/ui-toml/copy_then_borrow_mut/copy_then_borrow_mut.rs

@@ -0,0 +1,10 @@
+#[test]
+fn in_test() {
+    let mut a = [10; 2];
+    let _ = &mut { a }; // Do not lint
+}
+
+fn main() {
+    let mut a = [10; 2];
+    let _ = &mut { a }; //~ ERROR: mutable borrow
+}

tests/ui-toml/copy_then_borrow_mut/copy_then_borrow_mut.stderr

@@ -0,0 +1,16 @@
+error: mutable borrow of a value which was just copied
+  --> tests/ui-toml/copy_then_borrow_mut/copy_then_borrow_mut.rs:9:13
+   |
+LL |     let _ = &mut { a };
+   |             ^^^^^^^^^^
+   |
+   = note: `-D clippy::copy-then-borrow-mut` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::copy_then_borrow_mut)]`
+help: try building the reference inside the block
+   |
+LL -     let _ = &mut { a };
+LL +     let _ = { &mut a };
+   |
+
+error: aborting due to 1 previous error
+

tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr

@@ -31,6 +31,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-copy-then-borrow-mut-in-tests
            check-incompatible-msrv-in-tests
            check-private-items
            cognitive-complexity-threshold
@@ -123,6 +124,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-copy-then-borrow-mut-in-tests
            check-incompatible-msrv-in-tests
            check-private-items
            cognitive-complexity-threshold
@@ -215,6 +217,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-copy-then-borrow-mut-in-tests
            check-incompatible-msrv-in-tests
            check-private-items
            cognitive-complexity-threshold

tests/ui/copy_then_borrow_mut.fixed

@@ -0,0 +1,109 @@
+#![warn(clippy::copy_then_borrow_mut)]
+#![allow(clippy::deref_addrof)]
+
+fn main() {
+    let mut a = [0u8; 2];
+    let _ = { &mut a }; //~ ERROR: mutable borrow
+
+    let _ = &mut 'label: {
+        // Block is targeted by break
+        if a[0] == 1 {
+            break 'label 42u8;
+        }
+        a[0]
+    };
+
+    let mut a = vec![0u8; 2];
+    let _ = &mut { a }; // `a` is not `Copy`
+
+    let a = [0u8; 2];
+    let _ = &mut { a }; // `a` is not mutable
+
+    let _ = &mut { 42 }; // Do not lint on non-place expression
+
+    let _ = &mut {}; // Do not lint on empty block
+
+    macro_rules! mac {
+        ($a:expr) => {{ a }};
+    }
+    let _ = &mut mac!(a); // Do not lint on borrowed macro result
+
+    macro_rules! mac2 {
+        // Do not lint, as it depends on `Copy`-ness of `a`
+        ($x:expr) => {
+            &mut unsafe { $x }
+        };
+    }
+    let mut a = 0u8;
+    let _ = &mut mac2!(a);
+
+    let _ = &mut {
+        // Do not lint, the variable is defined inside the block
+        let mut a: [i32; 5] = (1, 2, 3, 4, 5).into();
+        a
+    };
+
+    let _ = &mut {
+        // Do not lint, the variable is defined inside the block
+        {
+            let mut a: [i32; 5] = (1, 2, 3, 4, 5).into();
+            a
+        }
+    };
+
+    struct S {
+        a: u32,
+    }
+
+    let mut s = S { a: 0 };
+    let _ = {
+        //~^ ERROR: mutable borrow
+        s.a = 32;
+        &mut s.a
+    };
+
+    let _ = &mut {
+        // Do not lint, the variable is defined inside the block
+        let mut s = S { a: 0 };
+        s.a
+    };
+
+    let mut c = (10, 20);
+    let _ = {
+        //~^ ERROR: mutable borrow
+        &mut c.0
+    };
+
+    let _ = &mut {
+        // Do not lint, the variable is defined inside the block
+        let mut c = (10, 20);
+        c.0
+    };
+
+    let mut t = [10, 20];
+    let _ = {
+        //~^ ERROR: mutable borrow
+        &mut t[0]
+    };
+
+    let _ = &mut {
+        // Do not lint, the variable is defined inside the block
+        let mut t = [10, 20];
+        t[0]
+    };
+
+    unsafe fn unsafe_func(_: &mut i32) {}
+    let mut a = 10;
+    // Unsafe block needed to call `unsafe_func`
+    let double_a_ref = unsafe {
+        //~^ ERROR: mutable borrow
+        unsafe_func(&mut a);
+        &mut a
+    };
+}
+
+#[test]
+fn in_test() {
+    let mut a = [10; 2];
+    let _ = { &mut a }; //~ ERROR: mutable borrow
+}