Add logical operation override tests. (#4469)

Add some shader validation and execution tests for overrides with
logical expressions where the expression uses another override in both
sides of the logical op, just the left hand side or just the right hand
side.

Author: dj2

src/webgpu/shader/execution/override.spec.ts

@@ -0,0 +1,87 @@
+export const description = `Test override execution`;
+
+import { makeTestGroup } from '../../../common/framework/test_group.js';
+import { keysOf } from '../../../common/util/data_tables.js';
+import { AllFeaturesMaxLimitsGPUTest } from '../../gpu_test.js';
+import { checkElementsEqual } from '../../util/check_contents.js';
+
+export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
+
+const kOverrideCases = {
+  logical_lhs_override: {
+    code: `x == 2 && 1 < 2`,
+  },
+  logical_rhs_override: {
+    code: `1 > 2 || x == 2`,
+  },
+  logical_both_override: {
+    code: `x > 2 || x == 2`,
+  },
+};
+
+g.test('logical')
+  .desc(`Test replacing an override in the LHS of a logical statement`)
+  .params(u => u.combine('case', keysOf(kOverrideCases)))
+  .fn(async t => {
+    const expr = kOverrideCases[t.params.case].code;
+    const code = `
+override x: u32 = 2;
+override y: bool = ${expr};
+
+@group(0) @binding(0) var<storage, read_write> v : vec4u;
+
+@compute @workgroup_size(1)
+fn main() {
+  if (y) {
+      v = vec4u(4, 4, 4, 4);
+  } else {
+      v = vec4u(1, 1, 1, 1);
+  }
+}`;
+
+    const pipeline = t.device.createComputePipeline({
+      layout: 'auto',
+      compute: {
+        module: t.device.createShaderModule({
+          code,
+        }),
+        entryPoint: 'main',
+      },
+    });
+
+    const buffer = t.makeBufferWithContents(
+      new Uint32Array([0, 0, 0, 0]),
+      GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    );
+
+    const bg = t.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        {
+          binding: 0,
+          resource: {
+            buffer,
+          },
+        },
+      ],
+    });
+
+    const encoder = t.device.createCommandEncoder();
+    const pass = encoder.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bg);
+    pass.dispatchWorkgroups(1, 1, 1);
+    pass.end();
+    t.queue.submit([encoder.finish()]);
+
+    const bufferReadback = await t.readGPUBufferRangeTyped(buffer, {
+      srcByteOffset: 0,
+      type: Uint32Array,
+      typedLength: 4,
+      method: 'copy',
+    });
+    const got: Uint32Array = bufferReadback.data;
+    const expected = new Uint32Array([4, 4, 4, 4]);
+
+    t.expectOK(checkElementsEqual(got, expected));
+  });

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

@@ -206,6 +206,21 @@ const kInitCases = {
     override y : i32;`,
     valid: true,
   },
+  logical_lhs_override: {
+    code: `override x = 2;
+      override y = x == 2 && 1 < 2;`,
+    valid: true,
+  },
+  logical_rhs_override: {
+    code: `override x = 2;
+      override y = 1 < 2 || x == 2;`,
+    valid: true,
+  },
+  logical_both_override: {
+    code: `override x = 2;
+      override y = x > 2 || x == 2;`,
+    valid: true,
+  },
 };
 
 g.test('initializer')