diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
index bd651a8..024f569 100644
--- a/LayoutTests/ChangeLog
+++ b/LayoutTests/ChangeLog
@@ -1,3 +1,17 @@
+2019-07-16  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r247493.
+        https://bugs.webkit.org/show_bug.cgi?id=199841
+
+        "The new whlsl-for-loop.html test is failing on the bots"
+        (Requested by rmorisset on #webkit).
+
+        Reverted changeset:
+
+        "[WHLSL] Desugar for loops and while loops"
+        https://bugs.webkit.org/show_bug.cgi?id=199726
+        https://trac.webkit.org/changeset/247493
+
 2019-07-16  Robin Morisset  <rmorisset@apple.com>
 
         [WHLSL] Desugar for loops and while loops
diff --git a/LayoutTests/webgpu/whlsl-for-loop-expected.txt b/LayoutTests/webgpu/whlsl-for-loop-expected.txt
deleted file mode 100644
index ae67e5f..0000000
--- a/LayoutTests/webgpu/whlsl-for-loop-expected.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-
-PASS forLoop 
-
diff --git a/LayoutTests/webgpu/whlsl-for-loop.html b/LayoutTests/webgpu/whlsl-for-loop.html
deleted file mode 100644
index 299a9cf..0000000
--- a/LayoutTests/webgpu/whlsl-for-loop.html
+++ /dev/null
@@ -1,153 +0,0 @@
-<!DOCTYPE html>
-<html>
-<meta charset=utf-8>
-<meta name="timeout" content="long">
-<title>Lvalues.</title>
-<script src="js/whlsl-test-harness.js"></script>
-<script src="js/webgpu-functions.js"></script>
-<script src="../resources/testharness.js"></script>
-<script src="../resources/testharnessreport.js"></script>
-<script>
-const whlslTests = {};
-
-whlslTests.forLoop = async () =>
-{
-    let program = `
-        int foo1(int x)
-        {
-            int sum = 0;
-            int i;
-            for (i = 0; i < x; i = i + 1) {
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo2(int x)
-        {
-            int sum = 0;
-            for (int i = 0; i < x; i = i + 1) {
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo3(int x)
-        {
-            int sum = 0;
-            int i = 100;
-            for (int i = 0; i < x; i = i + 1) {
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo4(int x)
-        {
-            int sum = 0;
-            for (int i = 0; i < x; i = i + 1) {
-                if (i == 4)
-                    continue;
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo5(int x)
-        {
-            int sum = 0;
-            for (int i = 0; i < x; i = i + 1) {
-                if (i == 5)
-                    break;
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo6(int x)
-        {
-            int sum = 0;
-            for (int i = 0; ; i = i + 1) {
-                if (i >= x)
-                    break;
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo7(int x)
-        {
-            int sum = 0;
-            int i = 0;
-            for ( ; ; i = i + 1) {
-                if (i >= x)
-                    break;
-                sum = sum + i;
-            }
-            return sum;
-        }
-        int foo8(int x)
-        {
-            int sum = 0;
-            int i = 0;
-            for ( ; ; ) {
-                if (i >= x)
-                    break;
-                sum = sum + i;
-                i = i + 1;
-            }
-            return sum;
-        }
-    `;
-    assert_equals(await callIntFunction(program, "foo1", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo1", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo1", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo2", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo2", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo2", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo3", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo3", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo3", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo4", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo4", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo4", [makeInt(5)]), 6);
-    assert_equals(await callIntFunction(program, "foo4", [makeInt(6)]), 11);
-    assert_equals(await callIntFunction(program, "foo5", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo5", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo5", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo5", [makeInt(6)]), 10);
-    assert_equals(await callIntFunction(program, "foo5", [makeInt(7)]), 10);
-    assert_equals(await callIntFunction(program, "foo6", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo6", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo6", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo6", [makeInt(6)]), 15);
-    assert_equals(await callIntFunction(program, "foo6", [makeInt(7)]), 21);
-    assert_equals(await callIntFunction(program, "foo7", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo7", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo7", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo7", [makeInt(6)]), 15);
-    assert_equals(await callIntFunction(program, "foo7", [makeInt(7)]), 21);
-    assert_equals(await callIntFunction(program, "foo8", [makeInt(3)]), 3);
-    assert_equals(await callIntFunction(program, "foo8", [makeInt(4)]), 6);
-    assert_equals(await callIntFunction(program, "foo8", [makeInt(5)]), 10);
-    assert_equals(await callIntFunction(program, "foo8", [makeInt(6)]), 15);
-    assert_equals(await callIntFunction(program, "foo8", [makeInt(7)]), 21);
-    await checkFail(
-        `
-            void foo(int x)
-            {
-                for (int i = 0; ; i = i + 1) {
-                    break;
-                    x = i;
-                }
-            }
-        `);
-    await checkFail(
-        `
-            int foo(int x)
-            {
-                for ( ; x < 10; ) {
-                    return 7;
-                }
-            }
-        `);
-}
-
-runTests(whlslTests);
-</script>
-</html>
-
diff --git a/LayoutTests/webgpu/whlsl-return-spec-tests.html b/LayoutTests/webgpu/whlsl-return-spec-tests.html
index e12c309..2621a40 100644
--- a/LayoutTests/webgpu/whlsl-return-spec-tests.html
+++ b/LayoutTests/webgpu/whlsl-return-spec-tests.html
@@ -111,16 +111,17 @@
                 return 11;
             }
         `);
-    await checkFail(
-        `
-            int foo(int x)
-            {
-                int y = 6;
-                if (x == 7)
-                    int y = 8;
-                return y;
-            }
-        `);
+
+    program = `
+        int foo(int x)
+        {
+            int y = 6;
+            if (x == 7)
+                int y = 8;
+            return y;
+        }
+    `;
+    assert_equals(await callIntFunction(program, "foo", [makeInt(7)]), 6);
 };
 
 whlslTests.returnReferenceToSameParameter = async () => {
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index 03a8fa7..dd316b6 100644
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,17 @@
+2019-07-16  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r247493.
+        https://bugs.webkit.org/show_bug.cgi?id=199841
+
+        "The new whlsl-for-loop.html test is failing on the bots"
+        (Requested by rmorisset on #webkit).
+
+        Reverted changeset:
+
+        "[WHLSL] Desugar for loops and while loops"
+        https://bugs.webkit.org/show_bug.cgi?id=199726
+        https://trac.webkit.org/changeset/247493
+
 2019-07-16  Per Arne Vollan  <pvollan@apple.com>
 
         Prewarm font cache with more fonts
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h
index 0e44612..5794d4e 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLAST.h
@@ -101,5 +101,6 @@
 #include "WHLSLVariableDeclaration.h"
 #include "WHLSLVariableDeclarationsStatement.h"
 #include "WHLSLVariableReference.h"
+#include "WHLSLWhileLoop.h"
 
 #endif
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLForLoop.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLForLoop.h
index fe5936c..f45b974 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLForLoop.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLForLoop.h
@@ -44,28 +44,33 @@
 
 class ForLoop : public Statement {
 public:
-    ForLoop(CodeLocation location, UniqueRef<Expression>&& condition, UniqueRef<Expression>&& increment, UniqueRef<Statement>&& body)
+    ForLoop(CodeLocation location, Variant<UniqueRef<Statement>, UniqueRef<Expression>>&& initialization, std::unique_ptr<Expression>&& condition, std::unique_ptr<Expression>&& increment, UniqueRef<Statement>&& body)
         : Statement(location)
+        , m_initialization(WTFMove(initialization))
         , m_condition(WTFMove(condition))
         , m_increment(WTFMove(increment))
         , m_body(WTFMove(body))
     {
     }
 
-    virtual ~ForLoop() = default;
+    virtual ~ForLoop()
+    {
+    }
 
     ForLoop(const ForLoop&) = delete;
     ForLoop(ForLoop&&) = default;
 
     bool isForLoop() const override { return true; }
 
-    Expression& condition() { return m_condition; }
-    Expression& increment() { return m_increment; }
+    Variant<UniqueRef<Statement>, UniqueRef<Expression>>& initialization() { return m_initialization; }
+    Expression* condition() { return m_condition.get(); }
+    Expression* increment() { return m_increment.get(); }
     Statement& body() { return m_body; }
 
 private:
-    UniqueRef<Expression> m_condition;
-    UniqueRef<Expression> m_increment;
+    Variant<UniqueRef<Statement>, UniqueRef<Expression>> m_initialization;
+    std::unique_ptr<Expression> m_condition;
+    std::unique_ptr<Expression> m_increment;
     UniqueRef<Statement> m_body;
 };
 
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStatement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStatement.h
index bad93ed..278ad2b 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStatement.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStatement.h
@@ -62,6 +62,7 @@
     virtual bool isSwitchStatement() const { return false; }
     virtual bool isTrap() const { return false; }
     virtual bool isVariableDeclarationsStatement() const { return false; }
+    virtual bool isWhileLoop() const { return false; }
 
     CodeLocation codeLocation() const { return m_codeLocation; }
     void updateCodeLocation(CodeLocation location) { m_codeLocation = location; }
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLWhileLoop.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLWhileLoop.h
new file mode 100644
index 0000000..55c0377
--- /dev/null
+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLWhileLoop.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#if ENABLE(WEBGPU)
+
+#include "WHLSLExpression.h"
+#include "WHLSLLexer.h"
+#include "WHLSLStatement.h"
+#include <wtf/UniqueRef.h>
+
+namespace WebCore {
+
+namespace WHLSL {
+
+namespace AST {
+
+class WhileLoop : public Statement {
+public:
+    WhileLoop(CodeLocation location, UniqueRef<Expression>&& conditional, UniqueRef<Statement>&& body)
+        : Statement(location)
+        , m_conditional(WTFMove(conditional))
+        , m_body(WTFMove(body))
+    {
+    }
+
+    virtual ~WhileLoop() = default;
+
+    WhileLoop(const WhileLoop&) = delete;
+    WhileLoop(WhileLoop&&) = default;
+
+    bool isWhileLoop() const override { return true; }
+
+    Expression& conditional() { return m_conditional; }
+    Statement& body() { return m_body; }
+
+private:
+    UniqueRef<Expression> m_conditional;
+    UniqueRef<Statement> m_body;
+};
+
+} // namespace AST
+
+}
+
+}
+
+SPECIALIZE_TYPE_TRAITS_WHLSL_STATEMENT(WhileLoop, isWhileLoop())
+
+#endif
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
index a206b45..2b57933 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
@@ -128,6 +128,7 @@
     void visit(AST::SwitchCase&) override;
     void visit(AST::Trap&) override;
     void visit(AST::VariableDeclarationsStatement&) override;
+    void visit(AST::WhileLoop&) override;
     void visit(AST::IntegerLiteral&) override;
     void visit(AST::UnsignedIntegerLiteral&) override;
     void visit(AST::FloatLiteral&) override;
@@ -349,9 +350,24 @@
     emitLoop(LoopConditionLocation::AfterBody, &doWhileLoop.conditional(), nullptr, doWhileLoop.body());
 }
 
+void FunctionDefinitionWriter::visit(AST::WhileLoop& whileLoop)
+{
+    emitLoop(LoopConditionLocation::BeforeBody, &whileLoop.conditional(), nullptr, whileLoop.body());
+}
+
 void FunctionDefinitionWriter::visit(AST::ForLoop& forLoop)
 {
-    emitLoop(LoopConditionLocation::BeforeBody, &forLoop.condition(), &forLoop.increment(), forLoop.body());
+    m_stringBuilder.append("{\n");
+
+    WTF::visit(WTF::makeVisitor([&](AST::Statement& statement) {
+        checkErrorAndVisit(statement);
+    }, [&](UniqueRef<AST::Expression>& expression) {
+        checkErrorAndVisit(expression);
+        takeLastValue(); // We don't need to do anything with the result.
+    }), forLoop.initialization());
+
+    emitLoop(LoopConditionLocation::BeforeBody, forLoop.condition(), forLoop.increment(), forLoop.body());
+    m_stringBuilder.append("}\n");
 }
 
 void FunctionDefinitionWriter::visit(AST::IfStatement& ifStatement)
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp
index 362a862..5cfc8e2 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.cpp
@@ -393,6 +393,14 @@
     m_out.print("continue");
 }
 
+void ASTDumper::visit(AST::WhileLoop& whileLoop)
+{
+    m_out.print("while (");
+    visit(whileLoop.conditional());
+    m_out.print(")");
+    visit(whileLoop.body());
+}
+
 void ASTDumper::visit(AST::DoWhileLoop& doWhileLoop)
 {
     m_out.print("do ");
@@ -404,10 +412,18 @@
 
 void ASTDumper::visit(AST::ForLoop& forLoop)
 {
-    m_out.print("for (; ");
-    visit(forLoop.condition());
+    m_out.print("for (");
+    WTF::visit(WTF::makeVisitor([&](UniqueRef<AST::Statement>& statement) {
+        visit(statement);
+    }, [&](UniqueRef<AST::Expression>& expression) {
+        visit(expression);
+    }), forLoop.initialization());
     m_out.print("; ");
-    visit(forLoop.increment());
+    if (forLoop.condition())
+        visit(*forLoop.condition());
+    m_out.print("; ");
+    if (forLoop.increment())
+        visit(*forLoop.increment());
     m_out.print(") ");
     visit(forLoop.body());
 }
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h
index cb3e110..0ab09ff 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLASTDumper.h
@@ -100,6 +100,7 @@
     void visit(AST::SwitchStatement&) override;
     void visit(AST::Trap&) override;
     void visit(AST::VariableDeclarationsStatement&) override;
+    void visit(AST::WhileLoop&) override;
     void visit(AST::VariableDeclaration&) override;
     void visit(AST::AssignmentExpression&) override;
     void visit(AST::CallExpression&) override;
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
index 721e0ba..06997bf 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
@@ -57,6 +57,7 @@
 #include "WHLSLSwitchStatement.h"
 #include "WHLSLTernaryExpression.h"
 #include "WHLSLVisitor.h"
+#include "WHLSLWhileLoop.h"
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
 #include <wtf/Ref.h>
@@ -500,6 +501,7 @@
     void visit(AST::LogicalNotExpression&) override;
     void visit(AST::LogicalExpression&) override;
     void visit(AST::IfStatement&) override;
+    void visit(AST::WhileLoop&) override;
     void visit(AST::DoWhileLoop&) override;
     void visit(AST::ForLoop&) override;
     void visit(AST::SwitchStatement&) override;
@@ -1245,6 +1247,13 @@
         checkErrorAndVisit(*ifStatement.elseBody());
 }
 
+void Checker::visit(AST::WhileLoop& whileLoop)
+{
+    if (!recurseAndRequireBoolType(whileLoop.conditional()))
+        return;
+    checkErrorAndVisit(whileLoop.body());
+}
+
 void Checker::visit(AST::DoWhileLoop& doWhileLoop)
 {
     checkErrorAndVisit(doWhileLoop.body());
@@ -1253,9 +1262,19 @@
 
 void Checker::visit(AST::ForLoop& forLoop)
 {
-    if (!recurseAndRequireBoolType(forLoop.condition()))
+    WTF::visit(WTF::makeVisitor([&](UniqueRef<AST::Statement>& statement) {
+        checkErrorAndVisit(statement);
+    }, [&](UniqueRef<AST::Expression>& expression) {
+        checkErrorAndVisit(expression);
+    }), forLoop.initialization());
+    if (error())
         return;
-    checkErrorAndVisit(forLoop.increment());
+    if (forLoop.condition()) {
+        if (!recurseAndRequireBoolType(*forLoop.condition()))
+            return;
+    }
+    if (forLoop.increment())
+        checkErrorAndVisit(*forLoop.increment());
     checkErrorAndVisit(forLoop.body());
 }
 
@@ -1415,7 +1434,7 @@
 
 void Checker::visit(AST::CommaExpression& commaExpression)
 {
-    ASSERT(!commaExpression.list().isEmpty());
+    ASSERT(commaExpression.list().size() > 0);
     Visitor::visit(commaExpression);
     if (error())
         return;
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
index 6991fb3..3660439 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
@@ -43,6 +43,7 @@
 #include "WHLSLTypeReference.h"
 #include "WHLSLVariableDeclaration.h"
 #include "WHLSLVariableReference.h"
+#include "WHLSLWhileLoop.h"
 
 namespace WebCore {
 
@@ -119,33 +120,48 @@
     if (error())
         return;
 
-    checkErrorAndVisit(ifStatement.body());
+    {
+        NameContext nameContext(&m_nameContext);
+        NameResolver newNameResolver(*this, nameContext);
+        newNameResolver.checkErrorAndVisit(ifStatement.body());
+    }
     if (error())
         return;
 
-    if (ifStatement.elseBody())
-        checkErrorAndVisit(*ifStatement.elseBody());
+    if (ifStatement.elseBody()) {
+        NameContext nameContext(&m_nameContext);
+        NameResolver newNameResolver(*this, nameContext);
+        newNameResolver.checkErrorAndVisit(*ifStatement.elseBody());
+    }
+}
+
+void NameResolver::visit(AST::WhileLoop& whileLoop)
+{
+    checkErrorAndVisit(whileLoop.conditional());
+    if (error())
+        return;
+
+    NameContext nameContext(&m_nameContext);
+    NameResolver newNameResolver(*this, nameContext);
+    newNameResolver.checkErrorAndVisit(whileLoop.body());
 }
 
 void NameResolver::visit(AST::DoWhileLoop& whileLoop)
 {
-    checkErrorAndVisit(whileLoop.body());
-    if (error())
-        return;
+    {
+        NameContext nameContext(&m_nameContext);
+        NameResolver newNameResolver(*this, nameContext);
+        newNameResolver.checkErrorAndVisit(whileLoop.body());
+    }
 
     checkErrorAndVisit(whileLoop.conditional());
 }
 
 void NameResolver::visit(AST::ForLoop& forLoop)
 {
-    checkErrorAndVisit(forLoop.condition());
-    if (error())
-        return;
-    checkErrorAndVisit(forLoop.increment());
-    if (error())
-        return;
-
-    checkErrorAndVisit(forLoop.body());
+    NameContext nameContext(&m_nameContext);
+    NameResolver newNameResolver(*this, nameContext);
+    newNameResolver.Visitor::visit(forLoop);
 }
 
 void NameResolver::visit(AST::VariableDeclaration& variableDeclaration)
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h
index 14cfb65..3acdadf 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.h
@@ -50,6 +50,7 @@
     void visit(AST::TypeReference&) override;
     void visit(AST::Block&) override;
     void visit(AST::IfStatement&) override;
+    void visit(AST::WhileLoop&) override;
     void visit(AST::DoWhileLoop&) override;
     void visit(AST::ForLoop&) override;
     void visit(AST::VariableDeclaration&) override;
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
index 2be1217..20cb939 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp
@@ -1063,8 +1063,7 @@
 
     AST::Statements statements;
     while (!peekTypes<Token::Type::RightCurlyBracket, Token::Type::Case, Token::Type::Default>()) {
-        bool allowVariableDeclarations = true;
-        PARSE(statement, Statement, allowVariableDeclarations);
+        PARSE(statement, Statement);
         statements.append(WTFMove(*statement));
     }
 
@@ -1143,52 +1142,51 @@
     }
 }
 
-auto Parser::parseForLoop() -> Expected<AST::Block, Error>
+auto Parser::parseForLoop() -> Expected<AST::ForLoop, Error>
 {
     CONSUME_TYPE(origin, For);
     CONSUME_TYPE(leftParenthesis, LeftParenthesis);
 
+    auto parseRemainder = [&](Variant<UniqueRef<AST::Statement>, UniqueRef<AST::Expression>>&& initialization) -> Expected<AST::ForLoop, Error> {
+        CONSUME_TYPE(semicolon, Semicolon);
+
+        std::unique_ptr<AST::Expression> condition(nullptr);
+        if (!tryType(Token::Type::Semicolon)) {
+            if (auto expression = parseExpression())
+                condition = (*expression).moveToUniquePtr();
+            else
+                return Unexpected<Error>(expression.error());
+            CONSUME_TYPE(secondSemicolon, Semicolon);
+        }
+
+        std::unique_ptr<AST::Expression> increment(nullptr);
+        if (!tryType(Token::Type::RightParenthesis)) {
+            if (auto expression = parseExpression())
+                increment = (*expression).moveToUniquePtr();
+            else
+                return Unexpected<Error>(expression.error());
+            CONSUME_TYPE(rightParenthesis, RightParenthesis);
+        }
+
+        PARSE(body, Statement);
+        AST::CodeLocation location(origin->codeLocation,  (*body)->codeLocation());
+        return AST::ForLoop(location, WTFMove(initialization), WTFMove(condition), WTFMove(increment), WTFMove(*body));
+    };
 
     auto variableDeclarations = backtrackingScope<Expected<AST::VariableDeclarationsStatement, Error>>([&]() {
         return parseVariableDeclarations();
     });
-    Optional<UniqueRef<AST::Statement>> initialization;
-    if (variableDeclarations)
-        initialization = static_cast<UniqueRef<AST::Statement>>(makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)));
-    else {
-        PARSE(effectfulExpression, EffectfulExpression);
-        initialization = WTFMove(*effectfulExpression);
+    if (variableDeclarations) {
+        UniqueRef<AST::Statement> declarationStatement = makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations));
+        return parseRemainder(WTFMove(declarationStatement));
     }
 
-    CONSUME_TYPE(semicolon, Semicolon);
+    PARSE(effectfulExpression, EffectfulExpression);
 
-    Optional<UniqueRef<AST::Expression>> condition;
-    auto secondSemicolon = tryType(Token::Type::Semicolon);
-    if (!secondSemicolon) {
-        PARSE(expression, Expression);
-        condition = WTFMove(*expression);
-        CONSUME_TYPE(secondSemicolon, Semicolon);
-    } else
-        condition = static_cast<UniqueRef<AST::Expression>>(makeUniqueRef<AST::BooleanLiteral>(*secondSemicolon, true));
-
-    Optional<UniqueRef<AST::Expression>> increment;
-    auto rightParenthesis = tryType(Token::Type::RightParenthesis);
-    if (!rightParenthesis) {
-        PARSE(expression, Expression);
-        increment = WTFMove(*expression);
-        CONSUME_TYPE(rightParenthesis, RightParenthesis);
-    } else
-        increment = static_cast<UniqueRef<AST::Expression>>(makeUniqueRef<AST::BooleanLiteral>(*origin, true)); // FIXME: NullLiteral would make more sense, but is buggy right now. Anything side-effect free is fine.
-
-    PARSE(body, Statement);
-    AST::CodeLocation location(origin->codeLocation,  (*body)->codeLocation());
-
-    auto forLoop = makeUniqueRef<AST::ForLoop>(location, WTFMove(*condition), WTFMove(*increment), WTFMove(*body));
-    AST::Statements statements = Vector<UniqueRef<AST::Statement>>::from(WTFMove(*initialization), WTFMove(forLoop));
-    return AST::Block(location, WTFMove(statements));
+    return parseRemainder(WTFMove(*effectfulExpression));
 }
 
-auto Parser::parseWhileLoop() -> Expected<AST::ForLoop, Error>
+auto Parser::parseWhileLoop() -> Expected<AST::WhileLoop, Error>
 {
     CONSUME_TYPE(origin, While);
     CONSUME_TYPE(leftParenthesis, LeftParenthesis);
@@ -1197,8 +1195,7 @@
     PARSE(body, Statement);
 
     AST::CodeLocation location(origin->codeLocation,  (*body)->codeLocation());
-    auto increment = makeUniqueRef<AST::BooleanLiteral>(*origin, true); // FIXME: NullLiteral would make more sense, but is buggy right now. Anything side-effect free is fine.
-    return AST::ForLoop(location, WTFMove(*conditional), WTFMove(increment), WTFMove(*body));
+    return AST::WhileLoop(location, WTFMove(*conditional), WTFMove(*body));
 }
 
 auto Parser::parseDoWhileLoop() -> Expected<AST::DoWhileLoop, Error>
@@ -1257,7 +1254,7 @@
     return AST::VariableDeclarationsStatement({ origin->startOffset(), endOffset }, WTFMove(result));
 }
 
-auto Parser::parseStatement(bool allowVariableDeclarations) -> Expected<UniqueRef<AST::Statement>, Error>
+auto Parser::parseStatement() -> Expected<UniqueRef<AST::Statement>, Error>
 {
     PEEK(token);
     switch (token->type) {
@@ -1275,11 +1272,11 @@
     }
     case Token::Type::For: {
         PARSE(forLoop, ForLoop);
-        return { makeUniqueRef<AST::Block>(WTFMove(*forLoop)) };
+        return { makeUniqueRef<AST::ForLoop>(WTFMove(*forLoop)) };
     }
     case Token::Type::While: {
         PARSE(whileLoop, WhileLoop);
-        return { makeUniqueRef<AST::ForLoop>(WTFMove(*whileLoop)) };
+        return { makeUniqueRef<AST::WhileLoop>(WTFMove(*whileLoop)) };
     }
     case Token::Type::Do: {
         PARSE(doWhileLoop, DoWhileLoop);
@@ -1349,33 +1346,27 @@
     }
 
     {
-        auto effectfulExpressionStatement = backtrackingScope<Expected<UniqueRef<AST::Statement>, Error>>([&]() -> Expected<UniqueRef<AST::Statement>, Error> {
+        auto effectfulExpression = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
             PARSE(result, EffectfulExpression);
             CONSUME_TYPE(semicolon, Semicolon);
             return result;
         });
-        if (effectfulExpressionStatement)
-            return effectfulExpressionStatement;
+        if (effectfulExpression)
+            return { makeUniqueRef<AST::EffectfulExpressionStatement>(WTFMove(*effectfulExpression)) };
     }
 
-    if (allowVariableDeclarations) {
-        PARSE(variableDeclarations, VariableDeclarations);
-        CONSUME_TYPE(semicolon, Semicolon);
-        return { makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)) };
-    }
-
-    return Unexpected<Error>("A variable declaration is only valid inside a block");
+    PARSE(variableDeclarations, VariableDeclarations);
+    CONSUME_TYPE(semicolon, Semicolon);
+    return { makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)) };
 }
 
-auto Parser::parseEffectfulExpression() -> Expected<UniqueRef<AST::Statement>, Error>
+auto Parser::parseEffectfulExpression() -> Expected<UniqueRef<AST::Expression>, Error>
 {
     PEEK(origin);
-    if (origin->type == Token::Type::Semicolon) {
-        AST::Statements statements;
-        return { makeUniqueRef<AST::Block>(*origin, WTFMove(statements)) };
-    }
-
     Vector<UniqueRef<AST::Expression>> expressions;
+    if (origin->type == Token::Type::Semicolon)
+        return { makeUniqueRef<AST::CommaExpression>(*origin, WTFMove(expressions)) };
+
     PARSE(effectfulExpression, EffectfulAssignment);
     expressions.append(WTFMove(*effectfulExpression));
 
@@ -1385,11 +1376,10 @@
     }
 
     if (expressions.size() == 1)
-        return { makeUniqueRef<AST::EffectfulExpressionStatement>(WTFMove(expressions[0])) };
+        return WTFMove(expressions[0]);
     unsigned endOffset = m_lexer.peek().startOffset();
     AST::CodeLocation location(origin->startOffset(), endOffset);
-    auto expression = makeUniqueRef<AST::CommaExpression>(location, WTFMove(expressions));
-    return { makeUniqueRef<AST::EffectfulExpressionStatement>(WTFMove(expression)) };
+    return { makeUniqueRef<AST::CommaExpression>(location, WTFMove(expressions)) };
 }
 
 auto Parser::parseEffectfulAssignment() -> Expected<UniqueRef<AST::Expression>, Error>
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
index 901097d..400ce66 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h
@@ -91,6 +91,7 @@
 #include "WHLSLVariableDeclaration.h"
 #include "WHLSLVariableDeclarationsStatement.h"
 #include "WHLSLVariableReference.h"
+#include "WHLSLWhileLoop.h"
 #include <wtf/Expected.h>
 #include <wtf/Optional.h>
 #include <wtf/PrintStream.h>
@@ -202,14 +203,14 @@
     Expected<AST::IfStatement, Error> parseIfStatement();
     Expected<AST::SwitchStatement, Error> parseSwitchStatement();
     Expected<AST::SwitchCase, Error> parseSwitchCase();
-    Expected<AST::Block, Error> parseForLoop();
-    Expected<AST::ForLoop, Error> parseWhileLoop();
+    Expected<AST::ForLoop, Error> parseForLoop();
+    Expected<AST::WhileLoop, Error> parseWhileLoop();
     Expected<AST::DoWhileLoop, Error> parseDoWhileLoop();
     Expected<AST::VariableDeclaration, Error> parseVariableDeclaration(UniqueRef<AST::UnnamedType>&&);
     Expected<AST::VariableDeclarationsStatement, Error> parseVariableDeclarations();
-    Expected<UniqueRef<AST::Statement>, Error> parseStatement(bool allowVariableDeclaration = false);
+    Expected<UniqueRef<AST::Statement>, Error> parseStatement();
 
-    Expected<UniqueRef<AST::Statement>, Error> parseEffectfulExpression();
+    Expected<UniqueRef<AST::Expression>, Error> parseEffectfulExpression();
     Expected<UniqueRef<AST::Expression>, Error> parseEffectfulAssignment();
     struct SuffixExpression {
         SuffixExpression(UniqueRef<AST::Expression>&& result, bool success)
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStatementBehaviorChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStatementBehaviorChecker.cpp
index 474fc80..b4bcd61 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStatementBehaviorChecker.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStatementBehaviorChecker.cpp
@@ -44,6 +44,7 @@
 #include "WHLSLTrap.h"
 #include "WHLSLVariableDeclarationsStatement.h"
 #include "WHLSLVisitor.h"
+#include "WHLSLWhileLoop.h"
 #include <cstdint>
 #include <wtf/OptionSet.h>
 #include <wtf/Vector.h>
@@ -108,6 +109,9 @@
 
     void visit(AST::ForLoop& forLoop) override
     {
+        // The initialization always has a behavior of Nothing, which we already add unconditionally below,
+        // so we can just ignore the initialization.
+
         checkErrorAndVisit(forLoop.body());
         if (error())
             return;
@@ -118,6 +122,18 @@
         m_stack.append(b);
     }
 
+    void visit(AST::WhileLoop& whileLoop) override
+    {
+        checkErrorAndVisit(whileLoop.body());
+        if (error())
+            return;
+        auto b = m_stack.takeLast();
+        b.remove(Behavior::Break);
+        b.remove(Behavior::Continue);
+        b.add(Behavior::Nothing);
+        m_stack.append(b);
+    }
+
     void visit(AST::SwitchCase& switchCase) override
     {
         Visitor::visit(switchCase);
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
index 372e661..bf12e63 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
@@ -331,10 +331,10 @@
         checkErrorAndVisit(downcast<AST::SwitchStatement>(statement));
     else if (is<AST::Trap>(statement))
         checkErrorAndVisit(downcast<AST::Trap>(statement));
-    else {
-        ASSERT(is<AST::VariableDeclarationsStatement>(statement));
+    else if (is<AST::VariableDeclarationsStatement>(statement))
         checkErrorAndVisit(downcast<AST::VariableDeclarationsStatement>(statement));
-    }
+    else
+        checkErrorAndVisit(downcast<AST::WhileLoop>(statement));
 }
 
 void Visitor::visit(AST::Break&)
@@ -427,8 +427,15 @@
 
 void Visitor::visit(AST::ForLoop& forLoop)
 {
-    checkErrorAndVisit(forLoop.condition());
-    checkErrorAndVisit(forLoop.increment());
+    WTF::visit(WTF::makeVisitor([&](UniqueRef<AST::Statement>& statement) {
+        checkErrorAndVisit(statement);
+    }, [&](UniqueRef<AST::Expression>& expression) {
+        checkErrorAndVisit(expression);
+    }), forLoop.initialization());
+    if (forLoop.condition())
+        checkErrorAndVisit(*forLoop.condition());
+    if (forLoop.increment())
+        checkErrorAndVisit(*forLoop.increment());
     checkErrorAndVisit(forLoop.body());
 }
 
@@ -470,6 +477,12 @@
         checkErrorAndVisit(variableDeclaration.get());
 }
 
+void Visitor::visit(AST::WhileLoop& whileLoop)
+{
+    checkErrorAndVisit(whileLoop.conditional());
+    checkErrorAndVisit(whileLoop.body());
+}
+
 void Visitor::visit(AST::VariableDeclaration& variableDeclaration)
 {
     if (variableDeclaration.type())
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
index a3fa247..ec396fd 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
@@ -85,6 +85,7 @@
 class SwitchStatement;
 class Trap;
 class VariableDeclarationsStatement;
+class WhileLoop;
 class VariableDeclaration;
 class AssignmentExpression;
 class CallExpression;
@@ -165,6 +166,7 @@
     virtual void visit(AST::SwitchStatement&);
     virtual void visit(AST::Trap&);
     virtual void visit(AST::VariableDeclarationsStatement&);
+    virtual void visit(AST::WhileLoop&);
     virtual void visit(AST::VariableDeclaration&);
     virtual void visit(AST::AssignmentExpression&);
     virtual void visit(AST::CallExpression&);
diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
index 2674e46..70ef35a 100644
--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
@@ -13256,6 +13256,7 @@
 		C21BF70121CD89C400227979 /* WHLSLDereferenceExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLDereferenceExpression.h; sourceTree = "<group>"; };
 		C21BF70221CD89C400227979 /* WHLSLEnumerationMemberLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLEnumerationMemberLiteral.h; sourceTree = "<group>"; };
 		C21BF70321CD89C500227979 /* WHLSLReturn.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLReturn.h; sourceTree = "<group>"; };
+		C21BF70421CD89C600227979 /* WHLSLWhileLoop.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLWhileLoop.h; sourceTree = "<group>"; };
 		C21BF70521CD89C700227979 /* WHLSLFunctionAttribute.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLFunctionAttribute.h; sourceTree = "<group>"; };
 		C21BF70621CD89C700227979 /* WHLSLCommaExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLCommaExpression.h; sourceTree = "<group>"; };
 		C21BF70721CD89C800227979 /* WHLSLNullLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLNullLiteral.h; sourceTree = "<group>"; };
@@ -17131,6 +17132,7 @@
 				C21BF71021CD89D000227979 /* WHLSLVariableDeclaration.h */,
 				C21BF71421CD89D300227979 /* WHLSLVariableDeclarationsStatement.h */,
 				C21BF71321CD89D200227979 /* WHLSLVariableReference.h */,
+				C21BF70421CD89C600227979 /* WHLSLWhileLoop.h */,
 			);
 			path = AST;
 			sourceTree = "<group>";