wgsl: Implement AbstractInt negation execution tests

src/resources/cache/hashes.json

@@ -103,5 +103,6 @@
   "webgpu/shader/execution/unary/i32_conversion.bin": "70bd317b",
   "webgpu/shader/execution/unary/u32_complement.bin": "b8dd9928",
   "webgpu/shader/execution/unary/u32_conversion.bin": "750cf298",
-  "webgpu/shader/execution/unary/ai_assignment.bin": "8123c23d"
+  "webgpu/shader/execution/unary/ai_assignment.bin": "8123c23d",
+  "webgpu/shader/execution/unary/ai_arithmetic.bin": "ada333c7"
 }

src/webgpu/listing_meta.json

@@ -1529,6 +1529,7 @@
   "webgpu:shader,execution,expression,call,user,ptr_params:write_ptr_to_member:*": { "subcaseMS": 0.000 },
   "webgpu:shader,execution,expression,call,user,ptr_params:write_ptr_to_element:*": { "subcaseMS": 0.000 },
   "webgpu:shader,execution,expression,call,user,ptr_params:mixed_ptr_parameters:*": { "subcaseMS": 0.000 },
+  "webgpu:shader,execution,expression,unary,ai_arithmetic:negation:*": { "subcaseMS": 0.000 },
   "webgpu:shader,execution,expression,unary,af_arithmetic:negation:*": { "subcaseMS": 2165.950 },
   "webgpu:shader,execution,expression,unary,af_assignment:abstract:*": { "subcaseMS": 788.400 },
   "webgpu:shader,execution,expression,unary,af_assignment:f16:*": { "subcaseMS": 1.000 },

src/webgpu/shader/execution/expression/unary/af_arithmetic.spec.ts

@@ -8,7 +8,7 @@ import { TypeAbstractFloat } from '../../../../util/conversion.js';
 import { onlyConstInputSource, run } from '../expression.js';
 
 import { d } from './af_arithmetic.cache.js';
-import { abstractUnary } from './unary.js';
+import { abstractFloatUnary } from './unary.js';
 
 export const g = makeTestGroup(GPUTest);
 
@@ -27,5 +27,13 @@ Accuracy: Correctly rounded
   )
   .fn(async t => {
     const cases = await d.get('negation');
-    await run(t, abstractUnary('-'), [TypeAbstractFloat], TypeAbstractFloat, t.params, cases, 1);
+    await run(
+      t,
+      abstractFloatUnary('-'),
+      [TypeAbstractFloat],
+      TypeAbstractFloat,
+      t.params,
+      cases,
+      1
+    );
   });

src/webgpu/shader/execution/expression/unary/ai_arithmetic.cache.ts

@@ -0,0 +1,11 @@
+import { abstractInt } from '../../../../util/conversion.js';
+import { fullI64Range } from '../../../../util/math.js';
+import { makeCaseCache } from '../case_cache.js';
+
+export const d = makeCaseCache('unary/ai_arithmetic', {
+  negation: () => {
+    return fullI64Range().map(e => {
+      return { input: abstractInt(e), expected: abstractInt(-e) };
+    });
+  },
+});

src/webgpu/shader/execution/expression/unary/ai_arithmetic.spec.ts

@@ -0,0 +1,30 @@
+export const description = `
+Execution Tests for the abstract integer arithmetic unary expression operations
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../gpu_test.js';
+import { TypeAbstractInt } from '../../../../util/conversion.js';
+import { onlyConstInputSource, run } from '../expression.js';
+
+import { d } from './ai_arithmetic.cache.js';
+import { abstractIntUnary } from './unary.js';
+
+export const g = makeTestGroup(GPUTest);
+
+g.test('negation')
+  .specURL('https://www.w3.org/TR/WGSL/#arithmetic-expr')
+  .desc(
+    `
+Expression: -x
+`
+  )
+  .params(u =>
+    u
+      .combine('inputSource', onlyConstInputSource)
+      .combine('vectorize', [undefined, 2, 3, 4] as const)
+  )
+  .fn(async t => {
+    const cases = await d.get('negation');
+    await run(t, abstractIntUnary('-'), [TypeAbstractInt], TypeAbstractInt, t.params, cases);
+  });

src/webgpu/shader/execution/expression/unary/unary.ts

@@ -1,5 +1,6 @@
 import {
   abstractFloatShaderBuilder,
+  abstractIntShaderBuilder,
   basicExpressionBuilder,
   ShaderBuilder,
 } from '../expression.js';
@@ -10,6 +11,11 @@ export function unary(op: string): ShaderBuilder {
 }
 
 /* @returns a ShaderBuilder that evaluates a prefix unary operation that returns AbstractFloats */
-export function abstractUnary(op: string): ShaderBuilder {
+export function abstractFloatUnary(op: string): ShaderBuilder {
   return abstractFloatShaderBuilder(value => `${op}(${value})`);
 }
+
+/* @returns a ShaderBuilder that evaluates a prefix unary operation that returns AbstractInts */
+export function abstractIntUnary(op: string): ShaderBuilder {
+  return abstractIntShaderBuilder(value => `${op}(${value})`);
+}