[naga wgsl-in] Allow trailing comma in switch cases

Author: reima

CHANGELOG.md

@@ -125,6 +125,7 @@ This allows using precompiled shaders without manually checking which backend's
 #### Naga
 
 - [wgsl-in] Allow a trailing comma in `@blend_src(…)` attributes. By @ErichDonGubler in [#8137](https://github.com/gfx-rs/wgpu/pull/8137).
+- [wgsl-in] Allow a trailing comma in the list of `case` values inside a `switch`. By @reima in [#8165](https://github.com/gfx-rs/wgpu/pull/8165).
 
 ## v26.0.4 (2025-08-07)
 

naga/src/front/wgsl/parse/mod.rs

@@ -2287,11 +2287,17 @@ impl Parser {
                                         let value = loop {
                                             let value = this.switch_value(lexer, ctx)?;
                                             if lexer.skip(Token::Separator(',')) {
-                                                if lexer.skip(Token::Separator(':')) {
+                                                // list of values ends with ':' or a compound statement
+                                                // indicated by an attribute or '{'
+                                                if matches!(
+                                                    lexer.peek().0,
+                                                    Token::Separator(':')
+                                                        | Token::Attribute
+                                                        | Token::Paren('{')
+                                                ) {
                                                     break value;
                                                 }
                                             } else {
-                                                lexer.skip(Token::Separator(':'));
                                                 break value;
                                             }
                                             cases.push(ast::SwitchCase {
@@ -2301,6 +2307,8 @@ impl Parser {
                                             });
                                         };
 
+                                        lexer.skip(Token::Separator(':'));
+
                                         let body = this.block(lexer, ctx, brace_nesting_level)?.0;
 
                                         cases.push(ast::SwitchCase {

naga/tests/in/wgsl/control-flow.wgsl

@@ -58,6 +58,25 @@ fn control_flow() {
             pos = 3;
         }
     }
+
+    // trailing commas
+    switch pos {
+        case 1, {
+            pos = 0;
+        }
+        case 2,: {
+            pos = 1;
+        }
+        case 3, 4, {
+            pos = 2;
+        }
+        case 5, 6,: {
+            pos = 3;
+        }
+        default {
+            pos = 4;
+        }
+    }
 }
 
 fn switch_default_break(i: i32) {

naga/tests/out/glsl/wgsl-control-flow.main.Compute.glsl

@@ -58,19 +58,44 @@ void control_flow() {
         }
         case 2: {
             pos = 1;
-            return;
+            break;
         }
         case 3: {
             pos = 2;
+            break;
+        }
+        case 4: {
+            break;
+        }
+        default: {
+            pos = 3;
+            break;
+        }
+    }
+    int _e15 = pos;
+    switch(_e15) {
+        case 1: {
+            pos = 0;
             return;
         }
+        case 2: {
+            pos = 1;
+            return;
+        }
+        case 3:
         case 4: {
+            pos = 2;
             return;
         }
-        default: {
+        case 5:
+        case 6: {
             pos = 3;
             return;
         }
+        default: {
+            pos = 4;
+            return;
+        }
     }
 }
 

naga/tests/out/hlsl/wgsl-control-flow.hlsl

@@ -49,19 +49,44 @@ void control_flow()
         }
         case 2: {
             pos = int(1);
-            return;
+            break;
         }
         case 3: {
             pos = int(2);
+            break;
+        }
+        case 4: {
+            break;
+        }
+        default: {
+            pos = int(3);
+            break;
+        }
+    }
+    int _e15 = pos;
+    switch(_e15) {
+        case 1: {
+            pos = int(0);
             return;
         }
+        case 2: {
+            pos = int(1);
+            return;
+        }
+        case 3:
         case 4: {
+            pos = int(2);
             return;
         }
-        default: {
+        case 5:
+        case 6: {
             pos = int(3);
             return;
         }
+        default: {
+            pos = int(4);
+            return;
+        }
     }
 }
 

naga/tests/out/msl/wgsl-control-flow.msl

@@ -58,19 +58,44 @@ void control_flow(
         }
         case 2: {
             pos = 1;
-            return;
+            break;
         }
         case 3: {
             pos = 2;
+            break;
+        }
+        case 4: {
+            break;
+        }
+        default: {
+            pos = 3;
+            break;
+        }
+    }
+    int _e15 = pos;
+    switch(_e15) {
+        case 1: {
+            pos = 0;
             return;
         }
+        case 2: {
+            pos = 1;
+            return;
+        }
+        case 3:
         case 4: {
+            pos = 2;
             return;
         }
-        default: {
+        case 5:
+        case 6: {
             pos = 3;
             return;
         }
+        default: {
+            pos = 4;
+            return;
+        }
     }
 }