[wgsl] `i32` constructor needs to support abstract floats

[teoxoy]

https://threejs.org/examples/?q=webgpu#webgpu_lights_tiled uses this functionality. naga currently errors with:

Shader 'fragment' parsing error: abstract floating-point values cannot be automatically converted to integers
    ┌─ wgsl:142:192
    │
142 │         nodeVar13 = textureLoad( nodeUniform13, vec2<i32>( ( lightIndexes.value[ u32( ( ( ( nodeVar2.x + ( nodeVar2.y * 46.0 ) ) * 2.0 ) + f32( ( ( i ) / 4 ) ) ) ) ][ u32( ( ( i ) % 4 ) ) ] - 1 ), i32( 0.0 ) ), u32( 0u ) );
    │                                                                                                                                                                                                      ^^^^^^^^^^ see msg

Part of https://bugzilla.mozilla.org/show_bug.cgi?id=1916072#c5.

[ErichDonGubler]

Firefox tracking: bug 1952975

[jamienicol]

The error comes from here.

The spec says:

"If T is a floating point type, e is converted to i32, rounding towards zero.

Clicking on that first link confirms

AbstractFloat is also a floating point type.

Meaning we can follow the "converted" link to see how to do the conversion:

To convert a floating point scalar value X to an integer scalar type T:

If X is a NaN, the result is an indeterminate value in T.

If X is exactly representable in the target type T, then the result is that value.

Otherwise, the result is the value in T closest to truncate(X) and also exactly representable in the original floating point type.

I think this means we can simply use rust's conversion rules, eg value as i32

[jamienicol]

We also need to do this for u32(<abstract float>).

i64 and u64 aren't in the WGSL spec, but I presume we might as well implement them anyway using the same rules?

[jamienicol]

The only thing I don't think a rust cast guarantees that a WGSL conversion expects, is the "also exactly representable in the original floating point type" part. But since i32::MIN, i32::MAX, u32::MIN, and u32::MAX are exactly representable by f64 that doesn't seem like an issue to me.

For casting AbstractFloat to u64/i64 that would be harder to handle. But since those types aren't part of the WGSL spec I guess we're free to ignore that rule.

[jamienicol]

Oh I should also note, it seems we hadn't implemented TryFromAbstract<f64> for i32 because it's not a valid automatic conversion. So perhaps one might be worried that by implementing this, we will now allow automatic conversions when we shouldn't.

But one needn't worry: TypeInner::automatically_converts_to() etc will prevent that. We even have a test to ensure this is so