Expand the parsing logic of while_!

This is to allow arbitrary expressions
in the condition position

Author: sanchopanca

src/lib.rs

@@ -261,10 +261,48 @@ struct WhileLoop {
 
 impl Parse for WhileLoop {
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        let cond = input.parse()?;
-        let body = input.parse::<Block>()?;
+        // Use the same lookahead approach as for_! macro
+        let checkpoint = input.fork();
+        let mut cond_tokens = proc_macro2::TokenStream::new();
+
+        // Collect all tokens until we find a valid parse point
+        while !input.is_empty() {
+            // Check if the remaining input can be parsed as "{ body } else { else_block }"
+            let remaining = input.fork();
+            if remaining.peek(Brace) {
+                // Try to parse: Block else Block
+                let test_remaining = remaining.fork();
+                if test_remaining.parse::<Block>().is_ok()
+                    && test_remaining.peek(Token![else])
+                    && test_remaining.peek2(Brace)
+                {
+                    let _ = test_remaining.parse::<Token![else]>();
+                    if test_remaining.parse::<Block>().is_ok() {
+                        // Successfully parsed the remaining as "{ body } else { else_block }"
+                        break;
+                    }
+                }
+            }
+
+            // Add the next token to our condition expression
+            let tt: proc_macro2::TokenTree = input.parse()?;
+            cond_tokens.extend(std::iter::once(tt));
+        }
+
+        // Parse the condition from collected tokens
+        let cond: Expr = if cond_tokens.is_empty() {
+            return Err(syn::Error::new(
+                checkpoint.span(),
+                "expected condition expression",
+            ));
+        } else {
+            syn::parse2(cond_tokens)?
+        };
+
+        let body: Block = input.parse()?;
         input.parse::<Token![else]>()?;
-        let else_block = input.parse::<Block>()?;
+        let else_block: Block = input.parse()?;
+
         Ok(WhileLoop {
             cond,
             body,

tests/test_while.rs

@@ -31,3 +31,109 @@ fn test_while_else() {
 
     assert!(was_in_else_branch);
 }
+
+#[test]
+fn test_while_var_in_last_position() {
+    let mut was_in_else_branch = false;
+    let mut x = 0;
+    let limit = 10;
+    while_! { x < limit {
+        if x == 5 {
+            break;
+        }
+        x += 1;
+    } else {
+        was_in_else_branch = true;
+    }}
+
+    assert!(!was_in_else_branch);
+}
+
+#[test]
+fn test_while_var_in_last_position_else() {
+    let mut was_in_else_branch = false;
+    let mut x = 0;
+    let limit = 10;
+    while_! { x < limit {
+        if x < 0 {
+            break;
+        }
+        x += 1;
+    } else {
+        was_in_else_branch = true;
+    }}
+
+    assert!(was_in_else_branch);
+}
+
+struct S {}
+
+impl S {
+    fn cond(self, x: i32) -> bool {
+        x < 10
+    }
+}
+
+#[test]
+fn test_while_inline_struct() {
+    let mut was_in_else_branch = false;
+    let mut x = 0;
+    while_! { (S {}).cond(x) {
+        if x == 5 {
+            break;
+        }
+        x += 1;
+    } else {
+        was_in_else_branch = true;
+    }}
+
+    assert!(!was_in_else_branch);
+}
+
+#[test]
+fn test_while_inline_struct_else() {
+    let mut was_in_else_branch = false;
+    let mut x = 0;
+    while_! { (S {}).cond(x) {
+        if x < 0 {
+            break;
+        }
+        x += 1;
+    } else {
+        was_in_else_branch = true;
+    }}
+
+    assert!(was_in_else_branch);
+}
+
+#[test]
+fn test_while_block_expr() {
+    let mut was_in_else_branch = false;
+    let mut x = 0;
+    while_! { { let s = S {}; s.cond(x) } {
+        if x == 5 {
+            break;
+        }
+        x += 1;
+    } else {
+        was_in_else_branch = true;
+    }}
+
+    assert!(!was_in_else_branch);
+}
+
+#[test]
+fn test_while_block_expr_else() {
+    let mut was_in_else_branch = false;
+    let mut x = 0;
+    while_! { { let s = S {}; s.cond(x) } {
+        if x < 0 {
+            break;
+        }
+        x += 1;
+    } else {
+        was_in_else_branch = true;
+    }}
+
+    assert!(was_in_else_branch);
+}