glsl-in: Fix missing stores for local declarations (#2029)

Previously, if a local variable was declared with a constant value, we would elide the store and instead give the variable an initial value (as if it was a global variable). This caused variables to not be re-initialized each time through a loop.
gfx-rs · Aug 24, 2022 · e7ddd35 · e7ddd35
1 parent 48e7938
commit e7ddd35
Show file tree

Hide file tree

Showing 17 changed files with 112 additions and 97 deletions.
diff --git a/src/front/glsl/parser/declarations.rs b/src/front/glsl/parser/declarations.rs
@@ -190,19 +190,18 @@ impl<'source> ParsingContext<'source> {
                 })
                 .transpose()?;
 
-            // If the declaration has an initializer try to make a constant out of it,
-            // this is only strictly needed for global constant declarations (and if the
-            // initializer can't be made a constant it should throw an error) but we also
-            // try to do it for all other types of declarations.
-            let maybe_constant = if let Some((root, meta)) = init {
-                let is_const = ctx.qualifiers.storage.0 == StorageQualifier::Const;
-
-                match parser.solve_constant(ctx.ctx, root, meta) {
-                    Ok(res) => Some(res),
-                    // If the declaration is external (global scope) and is constant qualified
-                    // then the initializer must be a constant expression
-                    Err(err) if ctx.external && is_const => return Err(err),
-                    _ => None,
+            let is_const = ctx.qualifiers.storage.0 == StorageQualifier::Const;
+            let maybe_constant = if ctx.external {
+                if let Some((root, meta)) = init {
+                    match parser.solve_constant(ctx.ctx, root, meta) {
+                        Ok(res) => Some(res),
+                        // If the declaration is external (global scope) and is constant qualified
+                        // then the initializer must be a constant expression
+                        Err(err) if is_const => return Err(err),
+                        _ => None,
+                    }
+                } else {
+                    None
                 }
             } else {
                 None

diff --git a/src/front/glsl/variables.rs b/src/front/glsl/variables.rs
@@ -643,7 +643,7 @@ impl Parser {
             LocalVariable {
                 name: decl.name.clone(),
                 ty: decl.ty,
-                init: decl.init,
+                init: None,
             },
             decl.meta,
         );

diff --git a/tests/out/wgsl/246-collatz-comp.wgsl b/tests/out/wgsl/246-collatz-comp.wgsl
@@ -8,11 +8,11 @@ var<private> gl_GlobalInvocationID: vec3<u32>;
 
 fn collatz_iterations(n: u32) -> u32 {
     var n_1: u32;
-    var i: u32 = 0u;
+    var i: u32;
 
     _ = (&global.indices);
     n_1 = n;
-    _ = u32(0);
+    i = u32(0);
     loop {
         let _e7 = n_1;
         if !((_e7 != u32(1))) {

diff --git a/tests/out/wgsl/277-casting-vert.wgsl b/tests/out/wgsl/277-casting-vert.wgsl
@@ -1,7 +1,8 @@
 fn main_1() {
-    var a: f32 = 1.0;
+    var a: f32;
 
-    _ = f32(1);
+    a = f32(1);
+    return;
 }
 
 @vertex 

diff --git a/tests/out/wgsl/280-matrix-cast-vert.wgsl b/tests/out/wgsl/280-matrix-cast-vert.wgsl
@@ -1,8 +1,9 @@
 fn main_1() {
-    var a: mat4x4<f32> = mat4x4<f32>(vec4<f32>(1.0, 0.0, 0.0, 0.0), vec4<f32>(0.0, 1.0, 0.0, 0.0), vec4<f32>(0.0, 0.0, 1.0, 0.0), vec4<f32>(0.0, 0.0, 0.0, 1.0));
+    var a: mat4x4<f32>;
 
     let _e1 = f32(1);
-    _ = mat4x4<f32>(vec4<f32>(_e1, 0.0, 0.0, 0.0), vec4<f32>(0.0, _e1, 0.0, 0.0), vec4<f32>(0.0, 0.0, _e1, 0.0), vec4<f32>(0.0, 0.0, 0.0, _e1));
+    a = mat4x4<f32>(vec4<f32>(_e1, 0.0, 0.0, 0.0), vec4<f32>(0.0, _e1, 0.0, 0.0), vec4<f32>(0.0, 0.0, _e1, 0.0), vec4<f32>(0.0, 0.0, 0.0, _e1));
+    return;
 }
 
 @vertex 

diff --git a/tests/out/wgsl/901-lhs-field-select-vert.wgsl b/tests/out/wgsl/901-lhs-field-select-vert.wgsl
@@ -1,7 +1,7 @@
 fn main_1() {
-    var a: vec4<f32> = vec4<f32>(1.0, 1.0, 1.0, 1.0);
+    var a: vec4<f32>;
 
-    _ = vec4<f32>(1.0);
+    a = vec4<f32>(1.0);
     a.x = 2.0;
     return;
 }

diff --git a/tests/out/wgsl/932-for-loop-if-vert.wgsl b/tests/out/wgsl/932-for-loop-if-vert.wgsl
@@ -1,6 +1,7 @@
 fn main_1() {
-    var i: i32 = 0;
+    var i: i32;
 
+    i = 0;
     loop {
         let _e2 = i;
         if !((_e2 < 1)) {

diff --git a/tests/out/wgsl/bevy-pbr-frag.wgsl b/tests/out/wgsl/bevy-pbr-frag.wgsl
@@ -448,8 +448,8 @@ fn EnvBRDFApprox(f0_7: vec3<f32>, perceptual_roughness: f32, NoV_6: f32) -> vec3
     var f0_8: vec3<f32>;
     var perceptual_roughness_1: f32;
     var NoV_7: f32;
-    var c0_: vec4<f32> = vec4<f32>(-1.0, -0.027499999850988388, -0.5720000267028809, 0.02199999988079071);
-    var c1_: vec4<f32> = vec4<f32>(1.0, 0.042500000447034836, 1.0399999618530273, -0.03999999910593033);
+    var c0_: vec4<f32>;
+    var c1_: vec4<f32>;
     var r: vec4<f32>;
     var a004_: f32;
     var AB: vec2<f32>;
@@ -468,8 +468,8 @@ fn EnvBRDFApprox(f0_7: vec3<f32>, perceptual_roughness: f32, NoV_6: f32) -> vec3
     f0_8 = f0_7;
     perceptual_roughness_1 = perceptual_roughness;
     NoV_7 = NoV_6;
-    _ = vec4<f32>(-(1.0), -(0.027499999850988388), -(0.5720000267028809), 0.02199999988079071);
-    _ = vec4<f32>(1.0, 0.042500000447034836, 1.0399999618530273, -(0.03999999910593033));
+    c0_ = vec4<f32>(-(1.0), -(0.027499999850988388), -(0.5720000267028809), 0.02199999988079071);
+    c1_ = vec4<f32>(1.0, 0.042500000447034836, 1.0399999618530273, -(0.03999999910593033));
     let _e62 = perceptual_roughness_1;
     let _e64 = c0_;
     let _e66 = c1_;
@@ -939,7 +939,7 @@ fn dir_light(light_2: DirectionalLight, roughness_10: f32, NdotV_2: f32, normal:
     var NoH_5: f32;
     var LoH_7: f32;
     var diffuse_1: vec3<f32>;
-    var specularIntensity_3: f32 = 1.0;
+    var specularIntensity_3: f32;
     var specular_2: vec3<f32>;
 
     _ = (&global.ViewProj);
@@ -1010,6 +1010,7 @@ fn dir_light(light_2: DirectionalLight, roughness_10: f32, NdotV_2: f32, normal:
     let _e124 = LoH_7;
     let _e125 = Fd_Burley(_e121, _e122, _e123, _e124);
     diffuse_1 = (_e116 * _e125);
+    specularIntensity_3 = 1.0;
     _ = F0_3;
     _ = roughness_11;
     _ = half_vector;
@@ -1055,9 +1056,9 @@ fn main_1() {
     var F0_4: vec3<f32>;
     var diffuseColor_4: vec3<f32>;
     var R_4: vec3<f32>;
-    var light_accum: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
-    var i: i32 = 0;
-    var i_1: i32 = 0;
+    var light_accum: vec3<f32>;
+    var i: i32;
+    var i_1: i32;
     var diffuse_ambient: vec3<f32>;
     var specular_ambient: vec3<f32>;
 
@@ -1186,7 +1187,8 @@ fn main_1() {
     let _e217 = V_3;
     let _e219 = N_2;
     R_4 = reflect(-(_e217), _e219);
-    _ = vec3<f32>(0.0);
+    light_accum = vec3<f32>(0.0);
+    i = 0;
     loop {
         let _e227 = i;
         let _e228 = global_2.NumLights;
@@ -1222,6 +1224,7 @@ fn main_1() {
             i = (_e236 + 1);
         }
     }
+    i_1 = 0;
     loop {
         let _e264 = i_1;
         let _e265 = global_2.NumLights;

diff --git a/tests/out/wgsl/bits_glsl-frag.wgsl b/tests/out/wgsl/bits_glsl-frag.wgsl
@@ -1,24 +1,25 @@
 fn main_1() {
-    var i: i32 = 0;
-    var i2_: vec2<i32> = vec2<i32>(0, 0);
-    var i3_: vec3<i32> = vec3<i32>(0, 0, 0);
-    var i4_: vec4<i32> = vec4<i32>(0, 0, 0, 0);
-    var u: u32 = 0u;
-    var u2_: vec2<u32> = vec2<u32>(0u, 0u);
-    var u3_: vec3<u32> = vec3<u32>(0u, 0u, 0u);
-    var u4_: vec4<u32> = vec4<u32>(0u, 0u, 0u, 0u);
-    var f2_: vec2<f32> = vec2<f32>(0.0, 0.0);
-    var f4_: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+    var i: i32;
+    var i2_: vec2<i32>;
+    var i3_: vec3<i32>;
+    var i4_: vec4<i32>;
+    var u: u32;
+    var u2_: vec2<u32>;
+    var u3_: vec3<u32>;
+    var u4_: vec4<u32>;
+    var f2_: vec2<f32>;
+    var f4_: vec4<f32>;
 
-    _ = vec2<i32>(0);
-    _ = vec3<i32>(0);
-    _ = vec4<i32>(0);
-    _ = u32(0);
-    _ = vec2<u32>(u32(0));
-    _ = vec3<u32>(u32(0));
-    _ = vec4<u32>(u32(0));
-    _ = vec2<f32>(0.0);
-    _ = vec4<f32>(0.0);
+    i = 0;
+    i2_ = vec2<i32>(0);
+    i3_ = vec3<i32>(0);
+    i4_ = vec4<i32>(0);
+    u = u32(0);
+    u2_ = vec2<u32>(u32(0));
+    u3_ = vec3<u32>(u32(0));
+    u4_ = vec4<u32>(u32(0));
+    f2_ = vec2<f32>(0.0);
+    f4_ = vec4<f32>(0.0);
     _ = f4_;
     let _e33 = f4_;
     u = pack4x8snorm(_e33);

diff --git a/tests/out/wgsl/constant-array-size-vert.wgsl b/tests/out/wgsl/constant-array-size-vert.wgsl
@@ -6,10 +6,11 @@ struct Data {
 var<uniform> global: Data;
 
 fn function_() -> vec4<f32> {
-    var sum: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    var i: i32 = 0;
+    var sum: vec4<f32>;
+    var i: i32;
 
-    _ = vec4<f32>(f32(0));
+    sum = vec4<f32>(f32(0));
+    i = 0;
     loop {
         let _e9 = i;
         if !((_e9 < 42)) {

diff --git a/tests/out/wgsl/declarations-vert.wgsl b/tests/out/wgsl/declarations-vert.wgsl
@@ -28,8 +28,8 @@ var<private> array_2d: array<array<f32,2u>,2u>;
 var<private> array_toomanyd: array<array<array<array<array<array<array<f32,2u>,2u>,2u>,2u>,2u>,2u>,2u>;
 
 fn main_1() {
-    var positions: array<vec3<f32>,2u> = array<vec3<f32>,2u>(vec3<f32>(-1.0, 1.0, 0.0), vec3<f32>(-1.0, -1.0, 0.0));
-    var strct: TestStruct = TestStruct(1.0, 2.0);
+    var positions: array<vec3<f32>,2u>;
+    var strct: TestStruct;
     var from_input_array: vec4<f32>;
     var a_1: f32;
     var b: f32;
@@ -38,8 +38,8 @@ fn main_1() {
     _ = (&vert.a);
     _ = (&frag.position);
     _ = (&frag.a);
-    _ = array<vec3<f32>,2u>(vec3<f32>(-(1.0), 1.0, 0.0), vec3<f32>(-(1.0), -(1.0), 0.0));
-    _ = TestStruct(f32(1), f32(2));
+    positions = array<vec3<f32>,2u>(vec3<f32>(-(1.0), 1.0, 0.0), vec3<f32>(-(1.0), -(1.0), 0.0));
+    strct = TestStruct(f32(1), f32(2));
     let _e35 = in_array_2[1];
     from_input_array = _e35;
     let _e41 = array_2d[0][0];

diff --git a/tests/out/wgsl/expressions-frag.wgsl b/tests/out/wgsl/expressions-frag.wgsl
@@ -274,32 +274,35 @@ fn testUnaryOpMat(a_16: mat3x3<f32>) {
 }
 
 fn testStructConstructor() {
-    var tree: BST = BST(1);
+    var tree: BST;
 
-    _ = BST(1);
+    tree = BST(1);
+    return;
 }
 
 fn testNonScalarToScalarConstructor() {
-    var f: f32 = 1.0;
+    var f: f32;
 
-    _ = f32(mat2x2<f32>(vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0))[0].x);
+    f = f32(mat2x2<f32>(vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0))[0].x);
+    return;
 }
 
 fn testArrayConstructor() {
-    var tree_1: array<f32,1u> = array<f32,1u>(0.0);
+    var tree_1: array<f32,1u>;
 
-    _ = array<f32,1u>(0.0);
+    tree_1 = array<f32,1u>(0.0);
+    return;
 }
 
 fn testFreestandingConstructor() {
     return;
 }
 
 fn testNonImplicitCastVectorCast() {
-    var a_18: u32 = 1u;
+    var a_18: u32;
     var b_16: vec4<i32>;
 
-    _ = u32(1);
+    a_18 = u32(1);
     let _e3 = a_18;
     b_16 = vec4<i32>(i32(_e3));
     return;
@@ -384,12 +387,13 @@ fn testLength() {
 
 fn testConstantLength(a_24: array<f32,4u>) {
     var a_25: array<f32,4u>;
-    var len_1: i32 = 4;
+    var len_1: i32;
 
     _ = (&global_1.a);
     a_25 = a_24;
     _ = a_25;
-    _ = i32(4u);
+    len_1 = i32(4u);
+    return;
 }
 
 fn main_1() {

diff --git a/tests/out/wgsl/long-form-matrix-vert.wgsl b/tests/out/wgsl/long-form-matrix-vert.wgsl
@@ -1,36 +1,37 @@
 fn main_1() {
-    var splat: mat2x2<f32> = mat2x2<f32>(vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0));
-    var normal: mat2x2<f32> = mat2x2<f32>(vec2<f32>(1.0, 1.0), vec2<f32>(2.0, 2.0));
-    var from_matrix: mat2x4<f32> = mat2x4<f32>(vec4<f32>(1.0, 0.0, 0.0, 0.0), vec4<f32>(0.0, 1.0, 0.0, 0.0));
-    var a: mat2x2<f32> = mat2x2<f32>(vec2<f32>(1.0, 2.0), vec2<f32>(3.0, 4.0));
-    var b: mat2x2<f32> = mat2x2<f32>(vec2<f32>(1.0, 2.0), vec2<f32>(3.0, 4.0));
-    var c: mat3x3<f32> = mat3x3<f32>(vec3<f32>(1.0, 2.0, 3.0), vec3<f32>(1.0, 1.0, 1.0), vec3<f32>(1.0, 1.0, 1.0));
-    var d: mat3x3<f32> = mat3x3<f32>(vec3<f32>(2.0, 2.0, 1.0), vec3<f32>(1.0, 1.0, 1.0), vec3<f32>(1.0, 1.0, 1.0));
-    var e: mat4x4<f32> = mat4x4<f32>(vec4<f32>(2.0, 2.0, 1.0, 1.0), vec4<f32>(1.0, 1.0, 2.0, 2.0), vec4<f32>(1.0, 1.0, 1.0, 1.0), vec4<f32>(1.0, 1.0, 1.0, 1.0));
+    var splat: mat2x2<f32>;
+    var normal: mat2x2<f32>;
+    var from_matrix: mat2x4<f32>;
+    var a: mat2x2<f32>;
+    var b: mat2x2<f32>;
+    var c: mat3x3<f32>;
+    var d: mat3x3<f32>;
+    var e: mat4x4<f32>;
 
     let _e1 = f32(1);
-    _ = mat2x2<f32>(vec2<f32>(_e1, 0.0), vec2<f32>(0.0, _e1));
+    splat = mat2x2<f32>(vec2<f32>(_e1, 0.0), vec2<f32>(0.0, _e1));
     let _e9 = vec2<f32>(f32(1));
     let _e12 = vec2<f32>(f32(2));
-    _ = mat2x2<f32>(vec2<f32>(_e9.x, _e9.y), vec2<f32>(_e12.x, _e12.y));
+    normal = mat2x2<f32>(vec2<f32>(_e9.x, _e9.y), vec2<f32>(_e12.x, _e12.y));
     let _e26 = mat3x3<f32>(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(0.0, 0.0, 1.0));
-    _ = mat2x4<f32>(vec4<f32>(_e26[0].x, _e26[0].y, _e26[0].z, 0.0), vec4<f32>(_e26[1].x, _e26[1].y, _e26[1].z, 0.0));
-    _ = mat2x2<f32>(vec2<f32>(f32(1), f32(2)), vec2<f32>(f32(3), f32(4)));
+    from_matrix = mat2x4<f32>(vec4<f32>(_e26[0].x, _e26[0].y, _e26[0].z, 0.0), vec4<f32>(_e26[1].x, _e26[1].y, _e26[1].z, 0.0));
+    a = mat2x2<f32>(vec2<f32>(f32(1), f32(2)), vec2<f32>(f32(3), f32(4)));
     let _e58 = vec2<f32>(f32(2), f32(3));
-    _ = mat2x2<f32>(vec2<f32>(f32(1), _e58.x), vec2<f32>(_e58.y, f32(4)));
+    b = mat2x2<f32>(vec2<f32>(f32(1), _e58.x), vec2<f32>(_e58.y, f32(4)));
     let _e73 = vec3<f32>(f32(1));
     let _e76 = vec3<f32>(f32(1));
-    _ = mat3x3<f32>(vec3<f32>(f32(1), f32(2), f32(3)), vec3<f32>(_e73.x, _e73.y, _e73.z), vec3<f32>(_e76.x, _e76.y, _e76.z));
+    c = mat3x3<f32>(vec3<f32>(f32(1), f32(2), f32(3)), vec3<f32>(_e73.x, _e73.y, _e73.z), vec3<f32>(_e76.x, _e76.y, _e76.z));
     let _e93 = vec2<f32>(f32(2));
     let _e97 = vec3<f32>(f32(1));
     let _e100 = vec3<f32>(f32(1));
-    _ = mat3x3<f32>(vec3<f32>(_e93.x, _e93.y, f32(1)), vec3<f32>(_e97.x, _e97.y, _e97.z), vec3<f32>(_e100.x, _e100.y, _e100.z));
+    d = mat3x3<f32>(vec3<f32>(_e93.x, _e93.y, f32(1)), vec3<f32>(_e97.x, _e97.y, _e97.z), vec3<f32>(_e100.x, _e100.y, _e100.z));
     let _e117 = vec2<f32>(f32(2));
     let _e120 = vec4<f32>(f32(1));
     let _e123 = vec2<f32>(f32(2));
     let _e126 = vec4<f32>(f32(1));
     let _e129 = vec4<f32>(f32(1));
-    _ = mat4x4<f32>(vec4<f32>(_e117.x, _e117.y, _e120.x, _e120.y), vec4<f32>(_e120.z, _e120.w, _e123.x, _e123.y), vec4<f32>(_e126.x, _e126.y, _e126.z, _e126.w), vec4<f32>(_e129.x, _e129.y, _e129.z, _e129.w));
+    e = mat4x4<f32>(vec4<f32>(_e117.x, _e117.y, _e120.x, _e120.y), vec4<f32>(_e120.z, _e120.w, _e123.x, _e123.y), vec4<f32>(_e126.x, _e126.y, _e126.z, _e126.w), vec4<f32>(_e129.x, _e129.y, _e129.z, _e129.w));
+    return;
 }
 
 @vertex 

diff --git a/tests/out/wgsl/math-functions-vert.wgsl b/tests/out/wgsl/math-functions-vert.wgsl
@@ -1,8 +1,8 @@
 fn main_1() {
-    var a: vec4<f32> = vec4<f32>(1.0, 1.0, 1.0, 1.0);
-    var b: vec4<f32> = vec4<f32>(2.0, 2.0, 2.0, 2.0);
+    var a: vec4<f32>;
+    var b: vec4<f32>;
     var m: mat4x4<f32>;
-    var i: i32 = 5;
+    var i: i32;
     var ceilOut: vec4<f32>;
     var roundOut: vec4<f32>;
     var floorOut: vec4<f32>;
@@ -48,13 +48,14 @@ fn main_1() {
     var smoothStepVector: vec4<f32>;
     var smoothStepMixed: vec4<f32>;
 
-    _ = vec4<f32>(1.0);
-    _ = vec4<f32>(2.0);
+    a = vec4<f32>(1.0);
+    b = vec4<f32>(2.0);
     let _e6 = a;
     let _e7 = b;
     let _e8 = a;
     let _e9 = b;
     m = mat4x4<f32>(vec4<f32>(_e6.x, _e6.y, _e6.z, _e6.w), vec4<f32>(_e7.x, _e7.y, _e7.z, _e7.w), vec4<f32>(_e8.x, _e8.y, _e8.z, _e8.w), vec4<f32>(_e9.x, _e9.y, _e9.z, _e9.w));
+    i = 5;
     _ = a;
     let _e35 = a;
     ceilOut = ceil(_e35);