Possibly Missed Optimization

This generates the following ASM. Godbolt

fn foo(i: i32) -> i64 {
    let i = i.abs() as i64;
    i + i
}

foo:
        mov     eax, edi
        neg     eax
        cmovs   eax, edi
        cdqe
        add     rax, rax
        ret

But, this generates the following ASM. Godbolt

fn foo(i: i32) -> i64 {
    i.abs() as i64 + i.abs() as i64
}

foo:
        mov     eax, edi
        neg     eax
        mov     ecx, edi
        cmovns  ecx, eax
        test    edi, edi
        cdqe
        mov     edx, edi
        cmovs   rdx, rax
        movsxd  rax, ecx
        add     rax, rdx
        ret

Doing a small reordering makes sure they compile down to same ASM. Godbolt

fn foo(i: i32) -> i64 {
    let i = i.abs() as i64;
    i + i
}

fn foo_other(i: i32) -> i64 {
    let i = i.abs();
    i as i64 + i as i64
}

foo:
        mov     eax, edi
        neg     eax
        cmovs   eax, edi
        cdqe
        add     rax, rax
        ret

foo_other = foo

Meta

rustc --version --verbose:

1.92.0

Start by reproducing the two Rust snippets with rustc 1.92.0 using the provided Godbolt links and compare their generated ASM. Investigate why repeating i.abs() as i64 prevents the optimization seen after introducing a local variable. Done means the equivalent expressions generate the same optimized code, with the behavior covered by an appropriate compiler test.