[naga wgsl-in] vecN() constructors and let type conversions (gfx-rs#7367)

* Support `vecN()` constructors (fixes gfx-rs#7356)
* Apply automatic conversions to the initializer for `let` bindings

Author: andyleiserson

CHANGELOG.md

@@ -239,6 +239,7 @@ By @wumpf in [#7144](https://github.com/gfx-rs/wgpu/pull/7144)
 - Allow WGSL const declarations to have abstract types. By @jamienicol in [#7055](https://github.com/gfx-rs/wgpu/pull/7055) and [#7222](https://github.com/gfx-rs/wgpu/pull/7222).
 - Allows override-sized arrays to resolve to the same size without causing the type arena to panic. By @KentSlaney in [#7082](https://github.com/gfx-rs/wgpu/pull/7082).
 - Allow abstract types to be used for WGSL switch statement selector and case selector expressions. By @jamienicol in [#7250](https://github.com/gfx-rs/wgpu/pull/7250).
+- Apply automatic conversions to `let` declarations, and accept `vecN()` as a constructor for vectors (in any context). By @andyleiserson in [#7367](https://github.com/gfx-rs/wgpu/pull/7367).
 
 #### General
 

naga/src/front/wgsl/lower/construction.rs

@@ -167,11 +167,25 @@ impl<'source> Lowerer<'source, '_> {
             // Empty constructor
             (Components::None, dst_ty) => match dst_ty {
                 Constructor::Type((result_ty, _)) => {
-                    return ctx.append_expression(crate::Expression::ZeroValue(result_ty), span)
+                    expr = crate::Expression::ZeroValue(result_ty);
                 }
-                Constructor::PartialVector { .. }
-                | Constructor::PartialMatrix { .. }
-                | Constructor::PartialArray => {
+                Constructor::PartialVector { size } => {
+                    // vec2(), vec3(), vec4() return vectors of abstractInts; the same
+                    // is not true of the similar constructors for matrices or arrays.
+                    // See https://www.w3.org/TR/WGSL/#vec2-builtin et seq.
+                    let result_ty = ctx.module.types.insert(
+                        crate::Type {
+                            name: None,
+                            inner: crate::TypeInner::Vector {
+                                size,
+                                scalar: crate::Scalar::ABSTRACT_INT,
+                            },
+                        },
+                        span,
+                    );
+                    expr = crate::Expression::ZeroValue(result_ty);
+                }
+                Constructor::PartialMatrix { .. } | Constructor::PartialArray => {
                     // We have no arguments from which to infer the result type, so
                     // partial constructors aren't acceptable here.
                     return Err(Box::new(Error::TypeNotInferable(ty_span)));

naga/src/front/wgsl/lower/mod.rs

@@ -1490,41 +1490,39 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                     let mut emitter = Emitter::default();
                     emitter.start(&ctx.function.expressions);
 
-                    let value =
-                        self.expression(l.init, &mut ctx.as_expression(block, &mut emitter))?;
+                    let explicit_ty = l
+                        .ty
+                        .map(|ty| self.resolve_ast_type(ty, &mut ctx.as_const(block, &mut emitter)))
+                        .transpose()?;
+
+                    let mut ectx = ctx.as_expression(block, &mut emitter);
+
+                    let (_ty, initializer) = self.type_and_init(
+                        l.name,
+                        Some(l.init),
+                        explicit_ty,
+                        AbstractRule::Concretize,
+                        &mut ectx,
+                    )?;
+
+                    // We passed `Some()` to `type_and_init`, so we
+                    // will get a lowered initializer expression back.
+                    let initializer =
+                        initializer.expect("type_and_init did not return an initializer");
 
                     // The WGSL spec says that any expression that refers to a
                     // `let`-bound variable is not a const expression. This
                     // affects when errors must be reported, so we can't even
                     // treat suitable `let` bindings as constant as an
                     // optimization.
-                    ctx.local_expression_kind_tracker.force_non_const(value);
-
-                    let explicit_ty = l
-                        .ty
-                        .map(|ty| self.resolve_ast_type(ty, &mut ctx.as_const(block, &mut emitter)))
-                        .transpose()?;
-
-                    if let Some(ty) = explicit_ty {
-                        let mut ctx = ctx.as_expression(block, &mut emitter);
-                        let init_ty = ctx.register_type(value)?;
-                        if !ctx.module.types[ty]
-                            .inner
-                            .equivalent(&ctx.module.types[init_ty].inner, &ctx.module.types)
-                        {
-                            return Err(Box::new(Error::InitializationTypeMismatch {
-                                name: l.name.span,
-                                expected: ctx.type_to_string(ty),
-                                got: ctx.type_to_string(init_ty),
-                            }));
-                        }
-                    }
+                    ctx.local_expression_kind_tracker
+                        .force_non_const(initializer);
 
                     block.extend(emitter.finish(&ctx.function.expressions));
                     ctx.local_table
-                        .insert(l.handle, Declared::Runtime(Typed::Plain(value)));
+                        .insert(l.handle, Declared::Runtime(Typed::Plain(initializer)));
                     ctx.named_expressions
-                        .insert(value, (l.name.name.to_string(), l.name.span));
+                        .insert(initializer, (l.name.name.to_string(), l.name.span));
 
                     return Ok(());
                 }

naga/src/proc/mod.rs

@@ -119,6 +119,8 @@ impl crate::Literal {
             (value, crate::ScalarKind::Sint, 8) => Some(Self::I64(value as _)),
             (1, crate::ScalarKind::Bool, crate::BOOL_WIDTH) => Some(Self::Bool(true)),
             (0, crate::ScalarKind::Bool, crate::BOOL_WIDTH) => Some(Self::Bool(false)),
+            (value, crate::ScalarKind::AbstractInt, 8) => Some(Self::AbstractInt(value as _)),
+            (value, crate::ScalarKind::AbstractFloat, 8) => Some(Self::AbstractFloat(value as _)),
             _ => None,
         }
     }

naga/tests/in/wgsl/abstract-types-const.wgsl

@@ -12,15 +12,23 @@
 // - all parameters' types are considered.
 // - all parameters are converted to the consensus type.
 
-const xvupaiai: vec2<u32> = vec2(42, 43);
-const xvfpaiai: vec2<f32> = vec2(44, 45);
+const xvipaiai: vec2<i32> = vec2(42, 43);
+const xvupaiai: vec2<u32> = vec2(44, 45);
+const xvfpaiai: vec2<f32> = vec2(46, 47);
+const xvfpafaf: vec2<f32> = vec2(48.0, 49.0);
+const xvfpaiaf: vec2<f32> = vec2(48, 49.0);
 
 const xvupuai: vec2<u32> = vec2(42u, 43);
 const xvupaiu: vec2<u32> = vec2(42, 43u); 
 
 const xvuuai: vec2<u32> = vec2<u32>(42u, 43);
 const xvuaiu: vec2<u32> = vec2<u32>(42, 43u);
 
+const xvip____: vec2<i32> = vec2();
+const xvup____: vec2<u32> = vec2();
+const xvfp____: vec2<f32> = vec2();
+const xmfp____: mat2x2f = mat2x2(vec2(), vec2());
+
 const xmfpaiaiaiai: mat2x2<f32> = mat2x2(1, 2, 3, 4);
 const xmfpafaiaiai: mat2x2<f32> = mat2x2(1.0, 2, 3, 4);
 const xmfpaiafaiai: mat2x2<f32> = mat2x2(1, 2.0, 3, 4);
@@ -41,9 +49,15 @@ const ivfs_af = vec2<f32>(1.0);
 const iafafaf = array<f32, 2>(1.0, 2.0);
 const iafaiai = array<f32, 2>(1, 2);
 
-const iafpafaf = array(1.0, 2.0);
-const iafpaiaf = array(1, 2.0);
+const iaipaiai = array(1,   2);
+const iafpaiaf = array(1,   2.0);
 const iafpafai = array(1.0, 2);
+const iafpafaf = array(1.0, 2.0);
+
+const xaipaiai: array<i32, 2> = array(1, 2);
+const xaupaiai: array<u32, 2> = array(1, 2);
+const xafpaiaf: array<f32, 2> = array(1,   2.0);
+const xafpafai: array<f32, 2> = array(1.0, 2);
 const xafpafaf: array<f32, 2> = array(1.0, 2.0);
 
 struct S {
@@ -61,6 +75,11 @@ const saf_iai: S = S(1.0,  1i, 1);
 const safai_u: S = S(1.0,  1,  1u);
 const safaiai: S = S(1.0,  1,  1);
 
+const xvisai: vec2<i32> = vec2(1);
+const xvusai: vec2<u32> = vec2(1);
+const xvfsai: vec2<f32> = vec2(1);
+const xvfsaf: vec2<f32> = vec2(1.0);
+
 // Vector construction with spreads
 const ivfr_f__f = vec3<f32>(vec2<f32>(1.0f, 2.0f), 3.0f);
 const ivfr_f_af = vec3<f32>(vec2<f32>(1.0f, 2.0f), 3.0 );

naga/tests/in/wgsl/abstract-types-let.toml

@@ -0,0 +1 @@
+targets = "SPIRV | METAL | GLSL | WGSL"

naga/tests/in/wgsl/abstract-types-let.wgsl

@@ -0,0 +1,115 @@
+// i/x: type inferred / explicit
+// vX/mX/aX: vector / matrix / array of X
+//     where X: u/i/f: u32 / i32 / f32
+// s: vector splat
+// r: vector spread (vector arg to vector constructor)
+// p: "partial" constructor (type parameter inferred)
+// u/i/f/ai/af: u32 / i32 / f32 / abstract float / abstract integer as parameter
+// _: just for alignment
+
+// Ensure that:
+// - the inferred type is correct.
+// - all parameters' types are considered.
+// - all parameters are converted to the consensus type.
+
+fn all_constant_arguments() {
+    let xvipaiai: vec2<i32> = vec2(42, 43);
+    let xvupaiai: vec2<u32> = vec2(44, 45);
+    let xvfpaiai: vec2<f32> = vec2(46, 47);
+    let xvfpafaf: vec2<f32> = vec2(48.0, 49.0);
+    let xvfpaiaf: vec2<f32> = vec2(48, 49.0);
+
+    let xvupuai: vec2<u32> = vec2(42u, 43);
+    let xvupaiu: vec2<u32> = vec2(42, 43u);
+
+    let xvuuai: vec2<u32> = vec2<u32>(42u, 43);
+    let xvuaiu: vec2<u32> = vec2<u32>(42, 43u);
+
+    let xvip____: vec2<i32> = vec2();
+    let xvup____: vec2<u32> = vec2();
+    let xvfp____: vec2<f32> = vec2();
+    let xmfp____: mat2x2f = mat2x2(vec2(), vec2());
+
+    let xmfpaiaiaiai: mat2x2<f32> = mat2x2(1, 2, 3, 4);
+    let xmfpafaiaiai: mat2x2<f32> = mat2x2(1.0, 2, 3, 4);
+    let xmfpaiafaiai: mat2x2<f32> = mat2x2(1, 2.0, 3, 4);
+    let xmfpaiaiafai: mat2x2<f32> = mat2x2(1, 2, 3.0, 4);
+    let xmfpaiaiaiaf: mat2x2<f32> = mat2x2(1, 2, 3, 4.0);
+
+    let xmfp_faiaiai: mat2x2<f32> = mat2x2(1.0f, 2, 3, 4);
+    let xmfpai_faiai: mat2x2<f32> = mat2x2(1, 2.0f, 3, 4);
+    let xmfpaiai_fai: mat2x2<f32> = mat2x2(1, 2, 3.0f, 4);
+    let xmfpaiaiai_f: mat2x2<f32> = mat2x2(1, 2, 3, 4.0f);
+
+    let xvispai: vec2<i32> = vec2(1);
+    let xvfspaf: vec2<f32> = vec2(1.0);
+    let xvis_ai: vec2<i32> = vec2<i32>(1);
+    let xvus_ai: vec2<u32> = vec2<u32>(1);
+    let xvfs_ai: vec2<f32> = vec2<f32>(1);
+    let xvfs_af: vec2<f32> = vec2<f32>(1.0);
+
+    let xafafaf: array<f32, 2> = array<f32, 2>(1.0, 2.0);
+    let xaf_faf: array<f32, 2> = array<f32, 2>(1.0f, 2.0);
+    let xafaf_f: array<f32, 2> = array<f32, 2>(1.0, 2.0f);
+    let xafaiai: array<f32, 2> = array<f32, 2>(1, 2);
+    let xai_iai: array<i32, 2> = array<i32, 2>(1i, 2);
+    let xaiai_i: array<i32, 2> = array<i32, 2>(1, 2i);
+
+    let xaipaiai: array<i32, 2> = array(1,   2);
+    let xafpaiai: array<f32, 2> = array(1,   2);
+    let xafpaiaf: array<f32, 2> = array(1,   2.0);
+    let xafpafai: array<f32, 2> = array(1.0, 2);
+    let xafpafaf: array<f32, 2> = array(1.0, 2.0);
+
+    let xavipai: array<vec3<i32>, 1> = array(vec3(1));
+    let xavfpai: array<vec3<f32>, 1> = array(vec3(1));
+    let xavfpaf: array<vec3<f32>, 1> = array(vec3(1.0));
+
+    // Construction with splats
+    let xvisai: vec2<i32> = vec2(1);
+    let xvusai: vec2<u32> = vec2(1);
+    let xvfsai: vec2<f32> = vec2(1);
+    let xvfsaf: vec2<f32> = vec2(1.0);
+
+    let iaipaiai = array(1,   2);
+    let iafpaiaf = array(1,   2.0);
+    let iafpafai = array(1.0, 2);
+    let iafpafaf = array(1.0, 2.0);
+}
+
+fn mixed_constant_and_runtime_arguments() {
+    var u: u32;
+    var i: i32;
+    var f: f32;
+
+    let xvupuai: vec2<u32> = vec2(u,  43);
+    let xvupaiu: vec2<u32> = vec2(42, u);
+    let xvfpfai: vec2<f32> = vec2(f, 47); // differs slightly from const version
+    let xvfpfaf: vec2<f32> = vec2(f, 49.0);
+
+    let xvuuai: vec2<u32> = vec2<u32>(u, 43);
+    let xvuaiu: vec2<u32> = vec2<u32>(42, u);
+
+    let xmfp_faiaiai: mat2x2<f32> = mat2x2(f, 2, 3, 4);
+    let xmfpai_faiai: mat2x2<f32> = mat2x2(1, f, 3, 4);
+    let xmfpaiai_fai: mat2x2<f32> = mat2x2(1, 2, f, 4);
+    let xmfpaiaiai_f: mat2x2<f32> = mat2x2(1, 2, 3, f);
+
+    let xaf_faf: array<f32, 2> = array<f32, 2>(f, 2.0);
+    let xafaf_f: array<f32, 2> = array<f32, 2>(1.0, f);
+    let xaf_fai: array<f32, 2> = array<f32, 2>(f, 2);
+    let xafai_f: array<f32, 2> = array<f32, 2>(1, f);
+    let xai_iai: array<i32, 2> = array<i32, 2>(i, 2);
+    let xaiai_i: array<i32, 2> = array<i32, 2>(1, i);
+
+    let xafp_faf: array<f32, 2> = array(f, 2.0);
+    let xafpaf_f: array<f32, 2> = array(1.0, f);
+    let xafp_fai: array<f32, 2> = array(f, 2);
+    let xafpai_f: array<f32, 2> = array(1, f);
+    let xaip_iai: array<i32, 2> = array(i, 2);
+    let xaipai_i: array<i32, 2> = array(1, i);
+
+    let xvisi: vec2<i32> = vec2(i);
+    let xvusu: vec2<u32> = vec2(u);
+    let xvfsf: vec2<f32> = vec2(f);
+}