inplace transparent wrapping or unwrapping elements of a Vec fails to optimize for types implementing Drop

[herkhinah]

I tried this code:

#[repr(transparent)]
struct WrappedClone {
    inner: String
}

#[no_mangle]
pub fn unwrap_clone(list: Vec<WrappedClone>) -> Vec<String> {
    list.into_iter().map(|s| s.inner).collect()
}

#[derive(Copy, Clone)]
struct UnwrappedCopy {
    a: u32,
    b: i64,
    c: [f32; 3]
}

#[repr(transparent)]
struct WrappedCopy {
    inner: UnwrappedCopy
}

#[no_mangle]
pub fn unwrap_copy(list: Vec<WrappedCopy>) -> Vec<UnwrappedCopy> {
    list.into_iter().map(|s| s.inner).collect()
}

I expected to see this happen: Both unwrap_clone and unwrap_copy should get optimized to just return the input unchanged.
Instead, this happened:
unwrap_copy get's optimized as espected:

unwrap_copy:
        mov     rax, rdi
        movups  xmm0, xmmword ptr [rsi]
        mov     rcx, qword ptr [rsi + 16]
        movups  xmmword ptr [rdi], xmm0
        mov     qword ptr [rdi + 16], rcx
        ret

unwrap_clone fails to get optimized and compiles into a loop:

unwrap_clone:
        push    rbp
        push    r15
        push    r14
        push    r13
        push    r12
        push    rbx
        push    rax
        mov     rbx, rdi
        mov     r12, qword ptr [rsi]
        mov     rdi, qword ptr [rsi + 8]
        mov     rax, qword ptr [rsi + 16]
        movabs  rsi, -6148914691236517205
        mov     r14, r12
        test    rax, rax
        je      .LBB0_10
        lea     rcx, [rax + 2*rax]
        lea     r14, [r12 + 8*rcx]
        shl     rax, 3
        lea     rax, [rax + 2*rax]
        xor     ecx, ecx
.LBB0_2:
        cmp     qword ptr [r12 + rcx], 0
        je      .LBB0_4
        add     rcx, 24
        cmp     rax, rcx
        jne     .LBB0_2
        jmp     .LBB0_10
.LBB0_4:
        lea     rdx, [rax - 24]
        lea     r14, [r12 + rcx]
        cmp     rdx, rcx
        je      .LBB0_10
        mov     qword ptr [rsp], rdi
        sub     rax, rcx
        add     rax, -24
        mul     rsi
        mov     r15, rdx
        lea     rbp, [r12 + rcx]
        add     rbp, 32
        shr     r15, 4
        mov     r13, qword ptr [rip + __rust_dealloc@GOTPCREL]
        jmp     .LBB0_6
.LBB0_8:
        add     rbp, 24
        dec     r15
        je      .LBB0_9
.LBB0_6:
        mov     rsi, qword ptr [rbp]
        test    rsi, rsi
        je      .LBB0_8
        mov     rdi, qword ptr [rbp - 8]
        mov     edx, 1
        call    r13
        jmp     .LBB0_8
.LBB0_9:
        mov     rdi, qword ptr [rsp]
        movabs  rsi, -6148914691236517205
.LBB0_10:
        sub     r14, r12
        mov     rax, r14
        mul     rsi
        shr     rdx, 4
        mov     qword ptr [rbx], r12
        mov     qword ptr [rbx + 8], rdi
        mov     qword ptr [rbx + 16], rdx
        mov     rax, rbx
        add     rsp, 8
        pop     rbx
        pop     r12
        pop     r13
        pop     r14
        pop     r15
        pop     rbp
        ret

Originally I thought that behavior was caused by the underlying type not implementing Copy but Drop seems to be the actual culprit.

link to godbolt

Meta

rustc --version --verbose:

rustc 1.75.0 (82e1608df 2023-12-21)
binary: rustc
commit-hash: 82e1608dfa6e0b5569232559e3d385fea5a93112
commit-date: 2023-12-21
host: x86_64-unknown-linux-gnu
release: 1.75.0
LLVM version: 17.0.6
Compiler returned: 0

[the8472]

.LBB0_2:
        cmp     qword ptr [r12 + rcx], rdx
        je      .LBB0_4
        add     rcx, 24
        cmp     rax, rcx
        jne     .LBB0_2
        jmp     .LBB0_10

This reminds me of the do-nothing-loop from #79308.

A necessary condition for the optimization to fail seems to be that the underlying type doesn't implement the Copy trait.

That's not quite true, e.g. this also optimizes even though Foo is not Copy:

struct Foo {
    a: usize,
    b: usize,
    c: usize
}

#[repr(transparent)]
struct WrappedClone {
    inner: Foo
}

#[no_mangle]
pub fn unwrap_clone(list: Vec<WrappedClone>) -> Vec<Foo> {
    list.into_iter().map(|s| s.inner).collect()
}

So it's likely due to String: Drop and the compiler fails to see that the drop can't happen.