wgsl: Add validation tests for override-sized arrays (#4470)

Make sure they can only be declared in the workgroup address space,
and that they cannot be nested in other types or directly constructed.

Author: jrprice

src/webgpu/listing_meta.json

@@ -2002,6 +2002,7 @@
   "webgpu:shader,validation,decl,let:initializer:*": { "subcaseMS": 0.706 },
   "webgpu:shader,validation,decl,let:module_scope:*": { "subcaseMS": 0.619 },
   "webgpu:shader,validation,decl,let:type:*": { "subcaseMS": 122.199 },
+  "webgpu:shader,validation,decl,override:array_size:*": { "subcaseMS": 44.868 },
   "webgpu:shader,validation,decl,override:function_scope:*": { "subcaseMS": 1.003 },
   "webgpu:shader,validation,decl,override:id:*": { "subcaseMS": 69.432 },
   "webgpu:shader,validation,decl,override:initializer:*": { "subcaseMS": 4.810 },

src/webgpu/shader/validation/decl/override.spec.ts

@@ -239,3 +239,70 @@ g.test('function_scope')
     const code = `fn foo() { override x : u32; }`;
     t.expectCompileResult(false, code);
   });
+
+const kArrayCases = {
+  workgroup_var: {
+    code: `var<workgroup> a: array<u32, size>;`,
+    valid_with_override_size: true,
+  },
+  private_var: {
+    code: `var<private> a: array<u32, size>;`,
+    valid_with_override_size: false,
+  },
+  uniform_var: {
+    code: `@group(0) @binding(0) var<uniform> a: array<vec4u, size>;`,
+    valid_with_override_size: false,
+  },
+  storage_var: {
+    code: `@group(0) @binding(0) var<storage> a: array<u32, size>;`,
+    valid_with_override_size: false,
+  },
+  function_var: {
+    code: `fn f() { var a: array<u32, size>; }`,
+    valid_with_override_size: false,
+  },
+  workgroup_ptr_param: {
+    code: `fn f(a: ptr<workgroup, array<u32, size>>) {}`,
+    valid_with_override_size: true,
+  },
+  private_ptr_param: {
+    code: `fn f(a: ptr<private, array<u32, size>>) {}`,
+    valid_with_override_size: false,
+  },
+  workgroup_ptr_let: {
+    code: `var<workgroup> a: array<u32, size>; fn f() { let a = &a; }`,
+    valid_with_override_size: true,
+  },
+  private_ptr_let: {
+    code: `var<private> a: array<u32, size>; fn f() { let a = &a; }`,
+    valid_with_override_size: false,
+  },
+  array_in_struct: {
+    code: `struct S { a: array<u32, size> };`,
+    valid_with_override_size: false,
+  },
+  array_in_array: {
+    code: `var<workgroup> a: array<array<u32, size>, 4>;`,
+    valid_with_override_size: false,
+  },
+  construct_array: {
+    code: `fn a() -> u32 { return array<u32, size>()[0]; }`,
+    valid_with_override_size: false,
+  },
+};
+
+g.test('array_size')
+  .desc(
+    'Test that override-sized arrays are only allowed in the workgroup address space, and cannot be nested in other types or constructed.'
+  )
+  .params(u => u.combine('case', keysOf(kArrayCases)).combine('stage', ['const', 'override']))
+  .fn(t => {
+    const testcase = kArrayCases[t.params.case];
+    const wgsl = `
+${t.params.stage} size = 1;
+${testcase.code}
+`;
+
+    // Using a `const` size is the control case that should always pass.
+    t.expectCompileResult(t.params.stage === 'const' || testcase.valid_with_override_size, wgsl);
+  });