From f36adeefaa88fba13cfaa0c79bd6b85a1313b4ce Mon Sep 17 00:00:00 2001
From: teoxoy <28601907+teoxoy@users.noreply.github.com>
Date: Thu, 17 Nov 2022 18:10:19 +0100
Subject: [PATCH] [glsl-out] introduce a new block for switch cases

---
 src/back/glsl/mod.rs                          | 22 +++++---
 tests/out/glsl/control-flow.main.Compute.glsl | 56 ++++++++++++-------
 2 files changed, 50 insertions(+), 28 deletions(-)

diff --git a/src/back/glsl/mod.rs b/src/back/glsl/mod.rs
index 3698b79781..72a5d46f77 100644
--- a/src/back/glsl/mod.rs
+++ b/src/back/glsl/mod.rs
@@ -1807,23 +1807,29 @@ impl<'a, W: Write> Writer<'a, W> {
                 for case in cases {
                     match case.value {
                         crate::SwitchValue::Integer(value) => {
-                            writeln!(self.out, "{}case {}{}:", l2, value, type_postfix)?
+                            write!(self.out, "{}case {}{}:", l2, value, type_postfix)?
                         }
-                        crate::SwitchValue::Default => writeln!(self.out, "{}default:", l2)?,
+                        crate::SwitchValue::Default => write!(self.out, "{}default:", l2)?,
+                    }
+
+                    let write_block_braces = !(case.fall_through && case.body.is_empty());
+                    if write_block_braces {
+                        writeln!(self.out, " {{")?;
+                    } else {
+                        writeln!(self.out)?;
                     }
 
                     for sta in case.body.iter() {
                         self.write_stmt(sta, ctx, l2.next())?;
                     }
 
-                    // Write fallthrough comment if the case is fallthrough,
-                    // otherwise write a break, if the case is not already
-                    // broken out of at the end of its body.
-                    if case.fall_through {
-                        writeln!(self.out, "{}/* fallthrough */", l2.next())?;
-                    } else if case.body.last().map_or(true, |s| !s.is_terminator()) {
+                    if !case.fall_through && case.body.last().map_or(true, |s| !s.is_terminator()) {
                         writeln!(self.out, "{}break;", l2.next())?;
                     }
+
+                    if write_block_braces {
+                        writeln!(self.out, "{}}}", l2)?;
+                    }
                 }
 
                 writeln!(self.out, "{}}}", level)?
diff --git a/tests/out/glsl/control-flow.main.Compute.glsl b/tests/out/glsl/control-flow.main.Compute.glsl
index a66c83a309..b877f9cb69 100644
--- a/tests/out/glsl/control-flow.main.Compute.glsl
+++ b/tests/out/glsl/control-flow.main.Compute.glsl
@@ -8,17 +8,20 @@ layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 
 void switch_default_break(int i) {
     switch(i) {
-        default:
+        default: {
             break;
+        }
     }
 }
 
 void switch_case_break() {
     switch(0) {
-        case 0:
+        case 0: {
             break;
-        default:
+        }
+        default: {
             break;
+        }
     }
     return;
 }
@@ -26,10 +29,12 @@ void switch_case_break() {
 void loop_switch_continue(int x) {
     while(true) {
         switch(x) {
-            case 1:
+            case 1: {
                 continue;
-            default:
+            }
+            default: {
                 break;
+            }
         }
     }
     return;
@@ -43,54 +48,65 @@ void main() {
     memoryBarrierShared();
     barrier();
     switch(1) {
-        default:
+        default: {
             pos = 1;
             break;
+        }
     }
     int _e4 = pos;
     switch(_e4) {
-        case 1:
+        case 1: {
             pos = 0;
             break;
-        case 2:
+        }
+        case 2: {
             pos = 1;
             break;
+        }
         case 3:
-            /* fallthrough */
-        case 4:
+        case 4: {
             pos = 2;
             break;
-        case 5:
+        }
+        case 5: {
             pos = 3;
             break;
+        }
         default:
-            /* fallthrough */
-        case 6:
+        case 6: {
             pos = 4;
             break;
+        }
     }
     switch(0u) {
-        case 0u:
+        case 0u: {
             break;
-        default:
+        }
+        default: {
             break;
+        }
     }
     int _e11 = pos;
     switch(_e11) {
-        case 1:
+        case 1: {
             pos = 0;
             break;
-        case 2:
+        }
+        case 2: {
             pos = 1;
             return;
-        case 3:
+        }
+        case 3: {
             pos = 2;
             return;
-        case 4:
+        }
+        case 4: {
             return;
-        default:
+        }
+        default: {
             pos = 3;
             return;
+        }
     }
 }