fix(coroutine): split overlapping state assignments

[MilkBlock]

r? @cijiugechu

Fix #149748

coroutine.rs generated self-assign stmt when crossing yield stmt, which confused the linter.

This PR inserts additional temporary variable to make linter happy.

Before Patch

  bb1: {
      StorageLive(_3);
      _3 = copy ((*_1).0: &i32);
      StorageLive(_4);
      _4 = copy ((*_1).1: &i32);
      nop;
      (((*_1) as variant#3).0: &i32) = copy ((*_1).2: &i32);
      StorageLive(_6);
      StorageLive(_7);
      _7 = copy _4;
      _0 = Option::<&i32>::Some(move _7);
  }
  

After Patch

  bb1: {
      StorageLive(_3);
      _3 = copy ((*_1).0: &i32);
      StorageLive(_4);
      _4 = copy ((*_1).1: &i32);
      nop;
      _10 = copy ((*_1).2: &i32);
      (((*_1) as variant#3).0: &i32) = move _10;
      StorageLive(_6);
      StorageLive(_7);
      _7 = copy _4;
      _0 = Option::<&i32>::Some(move _7);
  }

[rustbot]

Some changes occurred to MIR optimizations

cc @rust-lang/wg-mir-opt

[saethlin]

r? saethlin (the person you selected is not a compiler reviewer)

Did you check that the ICE reported still happens? I can't make the compiler hit it.

[MilkBlock]

r? saethlin (the person you selected is not a compiler reviewer)

Did you check that the ICE reported still happens? I can't make the compiler hit it.

This can be reproduced by

rustc +nightly --edition=2024 \
    -Zmir-enable-passes=+Inline,+ReferencePropagation \
    -Zlint-mir \
    ./tests/ui/coroutine/issue-149748.rs
rustc +nightly --version
rustc 1.97.0-nightly (ca9a134e0 2026-04-26)

given code in issue-149748.rs

//@ edition:2024
//@ compile-flags: -Zmir-enable-passes=+Inline,+ReferencePropagation -Zlint-mir
//@ check-pass

#![feature(gen_blocks)]
#![allow(unused_variables, path_statements)]

struct NonCopy(i32);

gen fn refs<'a, 'b>(x: &'a i32, y: &'b i32, z: &'b i32) -> &'b i32 {
    yield y;
    z;
}

gen fn moves(x: NonCopy, y: NonCopy, z: NonCopy) -> NonCopy {
    yield y;
    z;
}

fn main() {
    let z = 3;
    let mut refs_iter = refs(&1, &2, &z);
    assert_eq!(refs_iter.next(), Some(&3));

    let mut moves_iter = moves(NonCopy(1), NonCopy(2), NonCopy(3));
    assert!(matches!(moves_iter.next(), Some(_)));
}

[Amanieu]

I think the lint is just wrong here, the assignment isn't overlapping: it's copying from 2 disjoint fields of the same local.

[MilkBlock]

I think the lint is just wrong here, the assignment isn't overlapping: it's copying from 2 disjoint fields of the same local.

I think so. But how should we process this issue? Do revision on linter is not recommended I think.

[rust-bors]

☔ The latest upstream changes (presumably #154341) made this pull request unmergeable. Please resolve the merge conflicts.

[Amanieu]

I think that the lint should be updated to use something like this to determine whether 2 places alias:

fn places_alias<'tcx>(
    tcx: TyCtxt<'tcx>,
    local_decls: &IndexVec<Local, LocalDecl<'tcx>>,
    a: Place<'tcx>,
    b: Place<'tcx>,
) -> bool {
    if a.local != b.local || a.is_indirect() || b.is_indirect() {
        return false;
    }

    for ((prefix, elem_a), (_, elem_b)) in a.iter_projections().zip(b.iter_projections()) {
        // Continue until we find the first mismatching projection.
        if elem_a == elem_b {
            continue;
        }

        match (elem_a, elem_b) {
            // Disjoint fields don't alias except if they are union fields.
            (PlaceElem::Field(_, _), PlaceElem::Field(_, _)) => {
                let ty = prefix.ty(local_decls, tcx).ty;
                return ty.is_union();
            }

            // Disjoint slice elements don't alias.
            (
                PlaceElem::ConstantIndex { offset: offset_a, min_length: _, from_end: from_end_a },
                PlaceElem::ConstantIndex { offset: offset_b, min_length: _, from_end: from_end_b },
            ) if from_end_a == from_end_b && offset_a != offset_b => {
                return false;
            }

            // Conservatively assume the places may alias.
            _ => return true,
        }
    }

    // If the projections are identical *or* one is a prefix of the other then
    // the places alias.
    true
}

[saethlin]

The "linter" here is looking for bugs not for style, so in this case it is more appropriate to modify the lint.