[Design] confusing `target_pointer_width = "64"` usize convertion design

[loynoir]

Title

confusing target_pointer_width = "64" usize convertion design

Actual

        #[cfg(target_pointer_width = "64")]
        {
            let _ = usize::try_from(42u64).unwrap();
            let _ = usize::try_from(42u32).unwrap();
            let _ = usize::from(42u16);
        }

Expected

When under target_pointer_width 64, should always success, and try is not necessary.

        #[cfg(CONDITION)]
        {
            let _ = usize::from(42u64);
            let _ = usize::from(42u32);
            let _ = usize::from(42u16);
        }

Related

https://github.com/rust-lang/rust/blob/master/library/core/src/convert/num.rs

[Noratrieb]

This is deliberate, we don't want people writing unportable code by accident. This is why trait implementations are not made available conditionally.

[loynoir]

This is deliberate, we don't want people writing unportable code by accident.

Why is unportable?

Are there real world target_pointer_width = "64" hardware, which usize fail from u32 and u64, but ok from u16?

        #[cfg(target_pointer_width = "64")]
        {
            // let _ = usize::try_from(42u64).unwrap();
            // let _ = usize::try_from(42u32).unwrap();
            // let _ = usize::from(42u16);

            let _ = usize::from(42u64);
            let _ = usize::from(42u32);
            let _ = usize::from(42u16);
        }

[GKFX]

@loynoir If there was an implementation of From<u64> for usize on 64-bit targets but not on 32-bit targets, then users targetting 64-bit machines could compile let x: usize = 42u64.into(). There would be no requirement for the user to write that within #[cfg(target_pointer_width = "64")] and no visible indication that this code only built for 64-bit, particularly if the From trait is being used in a more complex way. Then, when they tried to use a 32-bit target, the code would unexpectedly fail to compile. This situation where From implementations disappear when changing platforms is the portability problem.

That said, I've never fully agreed with Rust's choice here - if like most users you never expect to target 16-bit, then you end up writing try_from().unwrap() which is both verbose and has the potential to panic. Or you use as usize, which has the potential to silently give the wrong result.

A possible middle ground would be to have usize::from_u16, usize::from_u32, usize::from_u64 and usize::to_uXX etc. defined only on platforms where that is lossless, which is a less subtle compatibility issue than conditionally defining the From trait.