clean up transmutes in core

[lukas-code]

• Use transmute_unchecked instead of transmute_copy for MaybeUninit::transpose.
• Use manual transmute for Option<Ordering> → i8.

[rustbot]

r? @thomcc

(rustbot has picked a reviewer for you, use r? to override)

[rustbot]

Hey! It looks like you've submitted a new PR for the library teams!

If this PR contains changes to any rust-lang/rust public library APIs then please comment with @rustbot label +T-libs-api -T-libs to tag it appropriately. If this PR contains changes to any unstable APIs please edit the PR description to add a link to the relevant API Change Proposal or create one if you haven't already. If you're unsure where your change falls no worries, just leave it as is and the reviewer will take a look and make a decision to forward on if necessary.

Examples of T-libs-api changes:

• Stabilizing library features
• Introducing insta-stable changes such as new implementations of existing stable traits on existing stable types
• Introducing new or changing existing unstable library APIs (excluding permanently unstable features / features without a tracking issue)
• Changing public documentation in ways that create new stability guarantees
• Changing observable runtime behavior of library APIs

[deltragon]

It might make sense to use ptr::from_ref and .cast::<T>() instead of as casts for these right away, see #109255.

[deltragon]

Suggested change

	let uninit_src = unsafe { &*(src as *const [T] as *const [MaybeUninit<T>]) };
	let uninit_src = unsafe { &*ptr::from_ref(src).cast::<[MaybeUninit<T>]>() };

[lukas-code]

I agree with this change, but I'd rather land it separately. IMO, if we decide to change these pointer casts (which are everywhere in core) they should be changed all at once, preferably with a lint.

[the8472]

this is introducing new uses of as, which can be avoided by using those methods.

[lukas-code]

Looks like cast doesn't work for unsized pointee types yet (and won't work without moderate changes to the compiler), but I've replaced the reference -> pointer casts with ptr::from_ref now.

[kadiwa4]

It uses match now. Maybe remove/edit the comment if that's no longer a problem.

[lukas-code]

Yeah, this essentially uses

const fn ordering_is_some1(c: Option<Ordering>, x: Ordering) -> bool {
    x as i8 == match c {
        Some(c) => c as i8,
        None => 2,
    }
}

instead of

const fn ordering_is_some2(c: Option<Ordering>, x: Ordering) -> bool {
    match c {
        Some(c) => c as i8 == x as i8,
        None => false,
    }
}

, because the first one optimizes better.

Do you have a suggestion for a better comment?

[kadiwa4]

// This is mapping None to 2 and then doing the comparison afterwards
// because it optimizes better.

[bors]

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

[bors]

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

[thomcc]

Hm, I'm not entirely sure I see why &*(ptr::from_ref(thing) as *const T) and such is an improvement.

As a concrete example, using transmute catches compile errors in the case where destination is thin pointer and the source is a fat pointer, which is not caught by that pattern. Obviously this code doesn't have that issue, but I don't really see the justification to make the change everywhere.

Am I missing something?

[lukas-code]

Yeah, I'm no longer convinced, that reborrows + pointer casts are better than transmuting references either. I just noticed, that we recommend this pattern in the transmute docs and use it in most parts if the standard library already.

I can drop the reference transmute change and just keep the transmute_copy -> transmute_unchecked in MaybeUninit::transpose and manual transmute for Option<Ordering> if these look fine too you.

[thomcc]

Yeah, those look fine, I'd r+ it with just that.

@rustbot author

[thomcc]

Oh, you already did it.

@bors r+

[bors]

📌 Commit 7e3b934 has been approved by thomcc

It is now in the queue for this repository.