[naga] Ensure globals in wgsl snapshot tests are reachable from an entry point

Convert tabs to spaces in access.wgsl

Author: andyleiserson

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

@@ -80,6 +80,76 @@ var<private> iavipai = array(vec3(1));
 var<private> iavfpai = array(vec3(1));
 var<private> iavfpaf = array(vec3(1.0));
 
+fn globals() {
+    _ = xvipaiai;
+    _ = xvupaiai;
+    _ = xvfpaiai;
+    _ = xvfpafaf;
+    _ = xvfpaiaf;
+
+    _ = xvupuai;
+    _ = xvupaiu;
+
+    _ = xvuuai;
+    _ = xvuaiu;
+
+    _ = xvip____;
+    _ = xvup____;
+    _ = xvfp____;
+    _ = xmfp____;
+
+    _ = xmfpaiaiaiai;
+    _ = xmfpafaiaiai;
+    _ = xmfpaiafaiai;
+    _ = xmfpaiaiafai;
+    _ = xmfpaiaiaiaf;
+
+    _ = xvispai;
+    _ = xvfspaf;
+    _ = xvis_ai;
+    _ = xvus_ai;
+    _ = xvfs_ai;
+    _ = xvfs_af;
+
+    _ = xafafaf;
+    _ = xafaiai;
+
+    _ = xaipaiai;
+    _ = xaupaiai;
+    _ = xafpaiaf;
+    _ = xafpafai;
+    _ = xafpafaf;
+
+    _ = xavipai;
+    _ = xavfpai;
+    _ = xavfpaf;
+
+    // Construction with splats
+    _ = xvisai;
+    _ = xvusai;
+    _ = xvfsai;
+    _ = xvfsaf;
+
+    _ = ivispai;
+    _ = ivfspaf;
+    _ = ivis_ai;
+    _ = ivus_ai;
+    _ = ivfs_ai;
+    _ = ivfs_af;
+
+    _ = iafafaf;
+    _ = iafaiai;
+
+    _ = iaipaiai;
+    _ = iafpafaf;
+    _ = iafpaiaf;
+    _ = iafpafai;
+
+    _ = iavipai;
+    _ = iavfpai;
+    _ = iavfpaf;
+}
+
 fn all_constant_arguments() {
     var xvipaiai: vec2<i32> = vec2(42, 43);
     var xvupaiai: vec2<u32> = vec2(44, 45);
@@ -278,6 +348,7 @@ fn mixed_constant_and_runtime_arguments() {
 
 @compute @workgroup_size(1)
 fn main() {
+    globals();
     all_constant_arguments();
     mixed_constant_and_runtime_arguments();
 }

naga/tests/in/wgsl/access.wgsl

@@ -6,26 +6,26 @@ struct GlobalConst {
     c: i32,
 }
 // tests msl padding insertion for global constants
-var<private> global_const: GlobalConst = GlobalConst(0u, vec3<u32>(0u, 0u, 0u), 0);
+var<private> msl_padding_global_const: GlobalConst = GlobalConst(0u, vec3<u32>(0u, 0u, 0u), 0);
 
 struct AlignedWrapper {
-	@align(8) value: i32
+    @align(8) value: i32
 }
 
 struct Bar {
-	_matrix: mat4x3<f32>,
-	matrix_array: array<mat2x2<f32>, 2>,
-	atom: atomic<i32>,
-	atom_arr: array<atomic<i32>, 10>,
-	arr: array<vec2<u32>, 2>,
-	data: array<AlignedWrapper>,
+    _matrix: mat4x3<f32>,
+    matrix_array: array<mat2x2<f32>, 2>,
+    atom: atomic<i32>,
+    atom_arr: array<atomic<i32>, 10>,
+    arr: array<vec2<u32>, 2>,
+    data: array<AlignedWrapper>,
 }
 
 @group(0) @binding(0)
 var<storage,read_write> bar: Bar;
 
 struct Baz {
-	m: mat3x2<f32>,
+    m: mat3x2<f32>,
 }
 
 @group(0) @binding(1)
@@ -35,11 +35,11 @@ var<uniform> baz: Baz;
 var<storage,read_write> qux: vec2<i32>;
 
 fn test_matrix_within_struct_accesses() {
-	var idx = 1;
+    var idx = 1;
 
     idx--;
 
-	// loads
+    // loads
     let l0 = baz.m;
     let l1 = baz.m[0];
     let l2 = baz.m[idx];
@@ -52,7 +52,7 @@ fn test_matrix_within_struct_accesses() {
 
     idx++;
 
-	// stores
+    // stores
     t.m = mat3x2<f32>(vec2<f32>(6.0), vec2<f32>(5.0), vec2<f32>(4.0));
     t.m[0] = vec2<f32>(9.0);
     t.m[idx] = vec2<f32>(90.0);
@@ -63,18 +63,18 @@ fn test_matrix_within_struct_accesses() {
 }
 
 struct MatCx2InArray {
-	am: array<mat4x2<f32>, 2>,
+    am: array<mat4x2<f32>, 2>,
 }
 
 @group(0) @binding(3)
 var<uniform> nested_mat_cx2: MatCx2InArray;
 
 fn test_matrix_within_array_within_struct_accesses() {
-	var idx = 1;
+    var idx = 1;
 
     idx--;
 
-	// loads
+    // loads
     let l0 = nested_mat_cx2.am;
     let l1 = nested_mat_cx2.am[0];
     let l2 = nested_mat_cx2.am[0][0];
@@ -88,7 +88,7 @@ fn test_matrix_within_array_within_struct_accesses() {
 
     idx++;
 
-	// stores
+    // stores
     t.am = array<mat4x2<f32>, 2>();
     t.am[0] = mat4x2<f32>(vec2<f32>(8.0), vec2<f32>(7.0), vec2<f32>(6.0), vec2<f32>(5.0));
     t.am[0][0] = vec2<f32>(9.0);
@@ -114,41 +114,42 @@ fn foo_vert(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4<f32> {
     let baz: f32 = foo;
     foo = 1.0;
 
-	test_matrix_within_struct_accesses();
-	test_matrix_within_array_within_struct_accesses();
+    _ = msl_padding_global_const;
+    test_matrix_within_struct_accesses();
+    test_matrix_within_array_within_struct_accesses();
 
     // test storage loads
-	let _matrix = bar._matrix;
-	let arr = bar.arr;
-	let index = 3u;
-	let b = bar._matrix[index].x;
-	let a = bar.data[arrayLength(&bar.data) - 2u].value;
-	let c = qux;
+    let _matrix = bar._matrix;
+    let arr = bar.arr;
+    let index = 3u;
+    let b = bar._matrix[index].x;
+    let a = bar.data[arrayLength(&bar.data) - 2u].value;
+    let c = qux;
 
-	// test pointer types
-	let data_pointer: ptr<storage, i32, read_write> = &bar.data[0].value;
-	let foo_value = read_from_private(&foo);
+    // test pointer types
+    let data_pointer: ptr<storage, i32, read_write> = &bar.data[0].value;
+    let foo_value = read_from_private(&foo);
 
-	// test array indexing
-	var c2 = array<i32, 5>(a, i32(b), 3, 4, 5);
-	c2[vi + 1u] = 42;
-	let value = c2[vi];
+    // test array indexing
+    var c2 = array<i32, 5>(a, i32(b), 3, 4, 5);
+    c2[vi + 1u] = 42;
+    let value = c2[vi];
 
-	test_arr_as_arg(array<array<f32, 10>, 5>());
+    test_arr_as_arg(array<array<f32, 10>, 5>());
 
-	return vec4<f32>(_matrix * vec4<f32>(vec4<i32>(value)), 2.0);
+    return vec4<f32>(_matrix * vec4<f32>(vec4<i32>(value)), 2.0);
 }
 
 @fragment
 fn foo_frag() -> @location(0) vec4<f32> {
-	// test storage stores
-	bar._matrix[1].z = 1.0;
-	bar._matrix = mat4x3<f32>(vec3<f32>(0.0), vec3<f32>(1.0), vec3<f32>(2.0), vec3<f32>(3.0));
-	bar.arr = array<vec2<u32>, 2>(vec2<u32>(0u), vec2<u32>(1u));
-	bar.data[1].value = 1;
-	qux = vec2<i32>();
+    // test storage stores
+    bar._matrix[1].z = 1.0;
+    bar._matrix = mat4x3<f32>(vec3<f32>(0.0), vec3<f32>(1.0), vec3<f32>(2.0), vec3<f32>(3.0));
+    bar.arr = array<vec2<u32>, 2>(vec2<u32>(0u), vec2<u32>(1u));
+    bar.data[1].value = 1;
+    qux = vec2<i32>();
 
-	return vec4<f32>(0.0);
+    return vec4<f32>(0.0);
 }
 
 fn assign_through_ptr_fn(p: ptr<function, u32>) {
@@ -163,7 +164,7 @@ fn assign_through_ptr() {
     var val = 33u;
     assign_through_ptr_fn(&val);
 
-	var arr = array<vec4<f32>, 2>(vec4(6.0), vec4(7.0));
+    var arr = array<vec4<f32>, 2>(vec4(6.0), vec4(7.0));
     assign_array_through_ptr_fn(&arr);
 }
 

naga/tests/in/wgsl/debug-symbol-large-source.wgsl

@@ -7418,6 +7418,11 @@ fn color23(p: vec2<f32>) -> vec3<f32> {
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    _ = t_diffuse;
+    _ = s_diffuse;
+    _ = t_normal;
+    _ = s_normal;
+
     color23(vec2(1, 2));
 
     var color = smoothstep(vec3<f32>(0.0), vec3<f32>(0.1), fract(in.world_pos));

naga/tests/in/wgsl/debug-symbol-terrain.wgsl

@@ -186,7 +186,7 @@ fn gen_terrain_fragment(in: GenVertexOutput) -> GenFragmentOutput {
     let v = terrain_vertex(p, gen_data.min_max_height);
 
     var vert_component: f32 = 0.;
-    
+
     switch comp_index {
         case 0u: { vert_component = v.position.x; }
         case 1u: { vert_component = v.position.y; }
@@ -275,6 +275,11 @@ fn color23(p: vec2<f32>) -> vec3<f32> {
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    _ = t_diffuse;
+    _ = s_diffuse;
+    _ = t_normal;
+    _ = s_normal;
+
     color23(vec2(1, 2));
 
     var color = smoothstep(vec3<f32>(0.0), vec3<f32>(0.1), fract(in.world_pos));

naga/tests/in/wgsl/f16.wgsl

@@ -51,6 +51,9 @@ var<storage, read_write> output: UniformCompatible;
 var<storage, read_write> output_arrays: StorageCompatible;
 
 fn f16_function(x: f16) -> f16 {
+   _ = private_variable;
+   var l: LayoutTest;
+
    var val: f16 = f16(constant_variable);
    // A number too big for f16
    val += 1h - 33333h;

naga/tests/in/wgsl/f64.wgsl

@@ -2,6 +2,7 @@ var<private> v: f64 = 1lf;
 const k: f64 = 2.0lf;
 
 fn f(x: f64) -> f64 {
+   _ = v;
    let y: f64 = 3e1lf + 4.0e2lf;
    var z = y + f64(5);
    var w = -1.0lf;

naga/tests/in/wgsl/image.wgsl

@@ -29,6 +29,7 @@ fn main(@builtin(local_invocation_id) local_id: vec3<u32>) {
     let value5 = textureLoad(image_array_src, itc, local_id.z, i32(local_id.z) + 1);
     let value6 = textureLoad(image_array_src, itc, i32(local_id.z), i32(local_id.z) + 1);
     let value7 = textureLoad(image_1d_src, i32(local_id.x), i32(local_id.z));
+    let value8 = textureLoad(image_dup_src, i32(local_id.x));
     // loads with uvec2 coords.
     let value1u = textureLoad(image_mipmapped_src, vec2<u32>(itc), i32(local_id.z));
     let value2u = textureLoad(image_multisampled_src, vec2<u32>(itc), i32(local_id.z));

naga/tests/in/wgsl/int64.wgsl

@@ -39,6 +39,7 @@ var<storage, read_write> output: UniformCompatible;
 var<storage, read_write> output_arrays: StorageCompatible;
 
 fn int64_function(x: i64) -> i64 {
+   _ = private_variable;
    var val: i64 = i64(constant_variable);
    // A number too big for i32
    val += 31li - 1002003004005006li + -0x7fffffffffffffffli;

naga/tests/in/wgsl/overrides.wgsl

@@ -27,4 +27,9 @@ fn main() {
     var gain_x_100 = gain_x_10 * 10.;
 
     store_override = gain;
+
+    _ = specular_param;
+    _ = width;
+    _ = inferred_f32;
+    _ = auto_conversion;
 }