From e49910bb0a512800f8d588480da5bcf6b5e2bccf Mon Sep 17 00:00:00 2001
From: Systemcluster <me@systemcluster.me>
Date: Thu, 18 Feb 2021 05:37:56 +0100
Subject: [PATCH] [wgsl] allow empty for statement headers

---
 src/front/wgsl/mod.rs   | 46 ++++++++++++++++++++++++++---------------
 src/front/wgsl/tests.rs | 10 +++++++++
 2 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/src/front/wgsl/mod.rs b/src/front/wgsl/mod.rs
index dd631448ac..120d332baa 100644
--- a/src/front/wgsl/mod.rs
+++ b/src/front/wgsl/mod.rs
@@ -1813,16 +1813,24 @@ impl Parser {
                 let mut block = Vec::new();
 
                 lexer.expect(Token::Paren('('))?;
-                let initialization =
-                    self.parse_statement(lexer, context.reborrow(), is_uniform_control_flow)?;
-                let condition = self.parse_general_expression(lexer, context.as_expression())?;
-                lexer.expect(Token::Separator(';'))?;
-                let mut continuing = None;
-                // manually parse the next statement here instead of calling parse_statement
-                // because the statement is not terminated with a semicolon
-                if let Token::Word(ident) = lexer.peek() {
+                let initialization = if lexer.skip(Token::Separator(';')) {
+                    None
+                } else {
+                    self.parse_statement(lexer, context.reborrow(), is_uniform_control_flow)?
+                };
+                let condition = if lexer.skip(Token::Separator(';')) {
+                    None
+                } else {
+                    let condition =
+                        Some(self.parse_general_expression(lexer, context.as_expression())?);
+                    lexer.expect(Token::Separator(';'))?;
+                    condition
+                };
+                let continuing = if let Token::Word(ident) = lexer.peek() {
+                    // manually parse the next statement here instead of calling parse_statement
+                    // because the statement is not terminated with a semicolon
                     let _ = lexer.next();
-                    continuing = Some(match context.lookup_ident.get(ident) {
+                    Some(match context.lookup_ident.get(ident) {
                         Some(&var_expr) => {
                             let left =
                                 self.parse_postfix(lexer, context.as_expression(), var_expr)?;
@@ -1843,19 +1851,23 @@ impl Parser {
                                 arguments,
                             }
                         }
-                    });
-                }
+                    })
+                } else {
+                    None
+                };
                 lexer.expect(Token::Paren(')'))?;
                 lexer.expect(Token::Paren('{'))?;
 
                 block.extend(initialization);
 
-                let mut body = [crate::Statement::If {
-                    condition,
-                    accept: Vec::new(),
-                    reject: [crate::Statement::Break].to_vec(),
-                }]
-                .to_vec();
+                let mut body = Vec::new();
+                if let Some(condition) = condition {
+                    body.push(crate::Statement::If {
+                        condition,
+                        accept: Vec::new(),
+                        reject: [crate::Statement::Break].to_vec(),
+                    });
+                }
                 while !lexer.skip(Token::Paren('}')) {
                     let s = self.parse_statement(lexer, context.reborrow(), false)?;
                     body.extend(s);
diff --git a/src/front/wgsl/tests.rs b/src/front/wgsl/tests.rs
index 9a419f600e..e24b4f88d5 100644
--- a/src/front/wgsl/tests.rs
+++ b/src/front/wgsl/tests.rs
@@ -144,6 +144,16 @@ fn parse_loop() {
     ",
     )
     .unwrap();
+    parse_str(
+        "
+        fn main() {
+            for(;;) {
+                break;
+            }
+        }
+    ",
+    )
+    .unwrap();
 }
 
 #[test]