Fix the issue of unused assignment from MIR liveness checking

Author: chenyukang

compiler/rustc_mir_transform/src/liveness.rs

@@ -45,6 +45,9 @@ struct Access {
     /// When we encounter multiple statements at the same location, we only increase the liveness,
     /// in order to avoid false positives.
     live: bool,
+    /// Is this a direct access to the place itself, no projections, or to a field?
+    /// This helps distinguish `x = ...` from `x.field = ...`
+    is_direct: bool,
 }
 
 #[tracing::instrument(level = "debug", skip(tcx), ret)]
@@ -650,15 +653,17 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
             |place: Place<'tcx>, kind, source_info: SourceInfo, live: &DenseBitSet<PlaceIndex>| {
                 if let Some((index, extra_projections)) = checked_places.get(place.as_ref()) {
                     if !is_indirect(extra_projections) {
+                        let is_direct = extra_projections.is_empty();
                         match assignments[index].entry(source_info) {
                             IndexEntry::Vacant(v) => {
-                                let access = Access { kind, live: live.contains(index) };
+                                let access = Access { kind, live: live.contains(index), is_direct };
                                 v.insert(access);
                             }
                             IndexEntry::Occupied(mut o) => {
                                 // There were already a sighting. Mark this statement as live if it
                                 // was, to avoid false positives.
                                 o.get_mut().live |= live.contains(index);
+                                o.get_mut().is_direct &= is_direct;
                             }
                         }
                     }
@@ -742,7 +747,7 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
                     continue;
                 };
                 let source_info = body.local_decls[place.local].source_info;
-                let access = Access { kind, live: live.contains(index) };
+                let access = Access { kind, live: live.contains(index), is_direct: true };
                 assignments[index].insert(source_info, access);
             }
         }
@@ -1048,26 +1053,28 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
 
             let Some((name, decl_span)) = self.checked_places.names[index] else { continue };
 
-            // We have outstanding assignments and with non-trivial drop.
-            // This is probably a drop-guard, so we do not issue a warning there.
-            if maybe_drop_guard(
+            let is_maybe_drop_guard = maybe_drop_guard(
                 tcx,
                 self.typing_env,
                 index,
                 &self.ever_dropped,
                 self.checked_places,
                 self.body,
-            ) {
-                continue;
-            }
+            );
 
             // We probed MIR in reverse order for dataflow.
             // We revert the vector to give a consistent order to the user.
-            for (source_info, Access { live, kind }) in statements.into_iter().rev() {
+            for (source_info, Access { live, kind, is_direct }) in statements.into_iter().rev() {
                 if live {
                     continue;
                 }
 
+                // If this place was dropped and has non-trivial drop,
+                // skip reporting field assignments.
+                if !is_direct && is_maybe_drop_guard {
+                    continue;
+                }
+
                 // Report the dead assignment.
                 let Some(hir_id) = source_info.scope.lint_root(&self.body.source_scopes) else {
                     continue;

tests/ui/lint/unused/unused-assign-148960.rs

@@ -0,0 +1,33 @@
+//@ check-fail
+#![deny(unused)]
+
+fn test_one_extra_assign() {
+    let mut value = b"0".to_vec(); //~ ERROR value assigned to `value` is never read
+    value = b"1".to_vec();
+    println!("{:?}", value);
+}
+
+fn test_two_extra_assign() {
+    let mut x = 1; //~ ERROR value assigned to `x` is never read
+    x = 2; //~ ERROR value assigned to `x` is never read
+    x = 3;
+    println!("{}", x);
+}
+
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn test_indirect_assign() {
+    let mut p = Point { x: 1, y: 1 }; //~ ERROR value assigned to `p` is never read
+    p = Point { x: 2, y: 2 };
+    p.x = 3;
+    println!("{}", p.y);
+}
+
+fn main() {
+    test_one_extra_assign();
+    test_two_extra_assign();
+    test_indirect_assign();
+}

tests/ui/lint/unused/unused-assign-148960.stderr

@@ -0,0 +1,40 @@
+error: value assigned to `value` is never read
+  --> $DIR/unused-assign-148960.rs:5:21
+   |
+LL |     let mut value = b"0".to_vec();
+   |                     ^^^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+note: the lint level is defined here
+  --> $DIR/unused-assign-148960.rs:2:9
+   |
+LL | #![deny(unused)]
+   |         ^^^^^^
+   = note: `#[deny(unused_assignments)]` implied by `#[deny(unused)]`
+
+error: value assigned to `x` is never read
+  --> $DIR/unused-assign-148960.rs:11:17
+   |
+LL |     let mut x = 1;
+   |                 ^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `x` is never read
+  --> $DIR/unused-assign-148960.rs:12:5
+   |
+LL |     x = 2;
+   |     ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `p` is never read
+  --> $DIR/unused-assign-148960.rs:23:17
+   |
+LL |     let mut p = Point { x: 1, y: 1 };
+   |                 ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: aborting due to 4 previous errors
+