uniformity: test uniformity when a loop body only returns

Consider: loop { s1 continuing { s2 } }

If the statement behaviour of s1 is exactly {Return}, then the statement
behaviour of the entire loop is {Return}. In particular, nonuniformity
effects do not leak out from s2 to the context after or outside of the
whole loop.

See the WGSL spec fix for gpuweb/gpuweb#5100

Test three new statement scenarios, each where s1 starts with `return;`,
but varying where a collective operation is placed:
 - immediately after the return statement
 - in the continuing block of the same loop
 - immediately after the loop, where the continuing block in the loop
   has a break-if. This case requires the analysis to avoid using a
   Next behaviour from the overall loop.
 - immediately after the loop

Fixed: #4476

Author: dneto0

src/webgpu/shader/validation/uniformity/uniformity.spec.ts

@@ -185,7 +185,17 @@ function generateOp(op: string): string {
   }
 }
 
-const kStatementKinds = ['if', 'for', 'while', 'switch', 'break-if'] as const;
+const kStatementKinds = [
+  'if',
+  'for',
+  'while',
+  'switch',
+  'break-if',
+  'loop-return-only-inside',
+  'loop-return-only-continuing',
+  'loop-return-only-break-if-then-after',
+  'loop-return-only-after',
+] as const;
 type kStatementType = (typeof kStatementKinds)[number];
 
 function generateConditionalStatement(
@@ -236,6 +246,48 @@ function generateConditionalStatement(
       }
       `;
     }
+    case 'loop-return-only-inside': {
+      // The loop body only returns. The uniformity of the operation
+      // is immaterial. Check analysis inside the loop body, after
+      // the unconditional return.
+      return `loop {
+        return;
+        if ${generateCondition(condition)} { ${generateOp(op)} }
+      }
+      `;
+    }
+    case 'loop-return-only-continuing': {
+      // The loop body only returns. The uniformity of the operation
+      // is immaterial. Check analysis in the continuing block.
+      return `loop {
+        return;
+        continuing {
+          if ${generateCondition(condition)} { ${generateOp(op)} }
+        }
+      }
+      `;
+    }
+    case 'loop-return-only-break-if-then-after': {
+      // The loop body only returns. The uniformity of the operation
+      // is immaterial.
+      return `loop {
+        return;
+        continuing {
+          break if true;
+        }
+      }
+      if ${generateCondition(condition)} { ${generateOp(op)} }
+      `;
+    }
+    case 'loop-return-only-after': {
+      // The loop body only returns. The uniformity of the operation
+      // is immaterial. Check analysis after the loop.
+      return `loop {
+        return;
+      }
+      if ${generateCondition(condition)} { ${generateOp(op)} }
+      `;
+    }
   }
 
   return code;
@@ -297,7 +349,12 @@ g.test('basics')
 
     code += `\n}\n`;
 
-    t.expectCompileResult(t.params.expectation || t.params.op.startsWith('control_case'), code);
+    t.expectCompileResult(
+      t.params.expectation ||
+        t.params.op.startsWith('control_case') ||
+        t.params.statement.startsWith('loop-return-only'),
+      code
+    );
   });
 
 const kSubgroupOps = [
@@ -384,7 +441,12 @@ g.test('basics,subgroups')
 
     code += `\n}\n`;
 
-    t.expectCompileResult(t.params.expectation || t.params.op.startsWith('control_case'), code);
+    t.expectCompileResult(
+      t.params.expectation ||
+        t.params.op.startsWith('control_case') ||
+        t.params.statement.startsWith('loop-return-only'),
+      code
+    );
   });
 
 const kFragmentBuiltinValues = [