diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 2e44398..cf3ebae 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -1126,8 +1126,8 @@
       "resolver/resolver_test_helper.cc",
       "resolver/resolver_test_helper.h",
       "resolver/side_effects_test.cc",
-      "resolver/static_assert_test.cc",
       "resolver/source_variable_test.cc",
+      "resolver/static_assert_test.cc",
       "resolver/storage_class_layout_validation_test.cc",
       "resolver/storage_class_validation_test.cc",
       "resolver/struct_layout_test.cc",
@@ -1349,11 +1349,11 @@
       "reader/wgsl/parser_impl_and_expression_test.cc",
       "reader/wgsl/parser_impl_argument_expression_list_test.cc",
       "reader/wgsl/parser_impl_assignment_stmt_test.cc",
-      "reader/wgsl/parser_impl_body_stmt_test.cc",
       "reader/wgsl/parser_impl_break_stmt_test.cc",
       "reader/wgsl/parser_impl_bug_cases_test.cc",
       "reader/wgsl/parser_impl_call_stmt_test.cc",
       "reader/wgsl/parser_impl_case_body_test.cc",
+      "reader/wgsl/parser_impl_compound_stmt_test.cc",
       "reader/wgsl/parser_impl_const_literal_test.cc",
       "reader/wgsl/parser_impl_continue_stmt_test.cc",
       "reader/wgsl/parser_impl_continuing_stmt_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 32dedeb..2d25330 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -944,11 +944,11 @@
       reader/wgsl/parser_impl_and_expression_test.cc
       reader/wgsl/parser_impl_argument_expression_list_test.cc
       reader/wgsl/parser_impl_assignment_stmt_test.cc
-      reader/wgsl/parser_impl_body_stmt_test.cc
       reader/wgsl/parser_impl_break_stmt_test.cc
       reader/wgsl/parser_impl_bug_cases_test.cc
       reader/wgsl/parser_impl_call_stmt_test.cc
       reader/wgsl/parser_impl_case_body_test.cc
+      reader/wgsl/parser_impl_compound_stmt_test.cc
       reader/wgsl/parser_impl_const_literal_test.cc
       reader/wgsl/parser_impl_continue_stmt_test.cc
       reader/wgsl/parser_impl_continuing_stmt_test.cc
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index 207c305..4aef26a 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -482,7 +482,7 @@
             return true;
         }
 
-        auto assertion = static_assert_stmt();
+        auto assertion = static_assert_statement();
         if (assertion.errored) {
             return Failure::kErrored;
         }
@@ -1368,7 +1368,7 @@
 
 // static_assert
 //   : STATIC_ASSERT expression
-Maybe<const ast::StaticAssert*> ParserImpl::static_assert_stmt() {
+Maybe<const ast::StaticAssert*> ParserImpl::static_assert_statement() {
     Source start;
     if (!match(Token::Type::kStaticAssert, &start)) {
         return Failure::kNoMatch;
@@ -1387,7 +1387,7 @@
 }
 
 // function_decl
-//   : function_header body_stmt
+//   : function_header compound_statement
 Maybe<const ast::Function*> ParserImpl::function_decl(AttributeList& attrs) {
     auto header = function_header();
     if (header.errored) {
@@ -1398,7 +1398,7 @@
             // function body. The AST isn't used as we've already errored, but this
             // catches any errors inside the body, and can help keep the parser in
             // sync.
-            expect_body_stmt();
+            expect_compound_statement();
         }
         return Failure::kErrored;
     }
@@ -1408,7 +1408,7 @@
 
     bool errored = false;
 
-    auto body = expect_body_stmt();
+    auto body = expect_compound_statement();
     if (body.errored) {
         errored = true;
     }
@@ -1624,9 +1624,9 @@
     return {builtin, ident.source};
 }
 
-// body_stmt
-//   : BRACE_LEFT statements BRACE_RIGHT
-Expect<ast::BlockStatement*> ParserImpl::expect_body_stmt() {
+// compound_statement
+//   : BRACE_LEFT statement* BRACE_RIGHT
+Expect<ast::BlockStatement*> ParserImpl::expect_compound_statement() {
     return expect_brace_block("", [&]() -> Expect<ast::BlockStatement*> {
         auto stmts = expect_statements();
         if (stmts.errored) {
@@ -1678,23 +1678,13 @@
 
 // statement
 //   : SEMICOLON
-//   | body_stmt?
-//   | if_stmt
-//   | switch_stmt
-//   | loop_stmt
-//   | for_stmt
-//   | while_stmt
-//   | non_block_statement
-//      : return_stmt SEMICOLON
-//      | func_call_stmt SEMICOLON
-//      | variable_stmt SEMICOLON
-//      | break_stmt SEMICOLON
-//      | continue_stmt SEMICOLON
-//      | DISCARD SEMICOLON
-//      | assignment_stmt SEMICOLON
-//      | increment_stmt SEMICOLON
-//      | decrement_stmt SEMICOLON
-//      | static_assert_stmt SEMICOLON
+//   | if_statement
+//   | switch_statement
+//   | loop_statement
+//   | for_statement
+//   | while_statement
+//   | compound_statement
+//   | non_block_statement   // Note, we inject an extra rule in here for simpler parsing
 Maybe<const ast::Statement*> ParserImpl::statement() {
     while (match(Token::Type::kSemicolon)) {
         // Skip empty statements
@@ -1702,7 +1692,6 @@
 
     // Non-block statements that error can resynchronize on semicolon.
     auto stmt = sync(Token::Type::kSemicolon, [&] { return non_block_statement(); });
-
     if (stmt.errored) {
         return Failure::kErrored;
     }
@@ -1710,7 +1699,7 @@
         return stmt;
     }
 
-    auto stmt_if = if_stmt();
+    auto stmt_if = if_statement();
     if (stmt_if.errored) {
         return Failure::kErrored;
     }
@@ -1718,7 +1707,7 @@
         return stmt_if.value;
     }
 
-    auto sw = switch_stmt();
+    auto sw = switch_statement();
     if (sw.errored) {
         return Failure::kErrored;
     }
@@ -1726,7 +1715,7 @@
         return sw.value;
     }
 
-    auto loop = loop_stmt();
+    auto loop = loop_statement();
     if (loop.errored) {
         return Failure::kErrored;
     }
@@ -1734,7 +1723,7 @@
         return loop.value;
     }
 
-    auto stmt_for = for_stmt();
+    auto stmt_for = for_statement();
     if (stmt_for.errored) {
         return Failure::kErrored;
     }
@@ -1742,7 +1731,7 @@
         return stmt_for.value;
     }
 
-    auto stmt_while = while_stmt();
+    auto stmt_while = while_statement();
     if (stmt_while.errored) {
         return Failure::kErrored;
     }
@@ -1751,7 +1740,7 @@
     }
 
     if (peek_is(Token::Type::kBraceLeft)) {
-        auto body = expect_body_stmt();
+        auto body = expect_compound_statement();
         if (body.errored) {
             return Failure::kErrored;
         }
@@ -1761,19 +1750,20 @@
     return Failure::kNoMatch;
 }
 
-// statement (continued)
-//   : return_stmt SEMICOLON
-//   | func_call_stmt SEMICOLON
-//   | variable_stmt SEMICOLON
-//   | break_stmt SEMICOLON
-//   | continue_stmt SEMICOLON
+// non_block_statement (continued)
+//   : return_statement SEMICOLON
+//   | func_call_statement SEMICOLON
+//   | variable_statement SEMICOLON
+//   | break_statement SEMICOLON
+//   | continue_statement SEMICOLON
 //   | DISCARD SEMICOLON
-//   | assignment_stmt SEMICOLON
-//   | increment_stmt SEMICOLON
-//   | decrement_stmt SEMICOLON
+//   | assignment_statement SEMICOLON
+//   | increment_statement SEMICOLON
+//   | decrement_statement SEMICOLON
+//   | static_assert_statement SEMICOLON
 Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
     auto stmt = [&]() -> Maybe<const ast::Statement*> {
-        auto ret_stmt = return_stmt();
+        auto ret_stmt = return_statement();
         if (ret_stmt.errored) {
             return Failure::kErrored;
         }
@@ -1781,7 +1771,7 @@
             return ret_stmt.value;
         }
 
-        auto func = func_call_stmt();
+        auto func = func_call_statement();
         if (func.errored) {
             return Failure::kErrored;
         }
@@ -1789,7 +1779,7 @@
             return func.value;
         }
 
-        auto var = variable_stmt();
+        auto var = variable_statement();
         if (var.errored) {
             return Failure::kErrored;
         }
@@ -1797,7 +1787,7 @@
             return var.value;
         }
 
-        auto b = break_stmt();
+        auto b = break_statement();
         if (b.errored) {
             return Failure::kErrored;
         }
@@ -1805,7 +1795,7 @@
             return b.value;
         }
 
-        auto cont = continue_stmt();
+        auto cont = continue_statement();
         if (cont.errored) {
             return Failure::kErrored;
         }
@@ -1813,7 +1803,13 @@
             return cont.value;
         }
 
-        auto assign = assignment_stmt();
+        Source source;
+        if (match(Token::Type::kDiscard, &source)) {
+            return create<ast::DiscardStatement>(source);
+        }
+
+        // Note, this covers assignment, increment and decrement
+        auto assign = assignment_statement();
         if (assign.errored) {
             return Failure::kErrored;
         }
@@ -1821,7 +1817,7 @@
             return assign.value;
         }
 
-        auto stmt_static_assert = static_assert_stmt();
+        auto stmt_static_assert = static_assert_statement();
         if (stmt_static_assert.errored) {
             return Failure::kErrored;
         }
@@ -1829,24 +1825,18 @@
             return stmt_static_assert.value;
         }
 
-        Source source;
-        if (match(Token::Type::kDiscard, &source)) {
-            return create<ast::DiscardStatement>(source);
-        }
-
         return Failure::kNoMatch;
     }();
 
     if (stmt.matched && !expect(stmt->Name(), Token::Type::kSemicolon)) {
         return Failure::kErrored;
     }
-
     return stmt;
 }
 
-// return_stmt
+// return_statement
 //   : RETURN expression?
-Maybe<const ast::ReturnStatement*> ParserImpl::return_stmt() {
+Maybe<const ast::ReturnStatement*> ParserImpl::return_statement() {
     Source source;
     if (!match(Token::Type::kReturn, &source)) {
         return Failure::kNoMatch;
@@ -1865,11 +1855,11 @@
     return create<ast::ReturnStatement>(source, expr.value);
 }
 
-// variable_stmt
+// variable_statement
 //   : variable_decl
 //   | variable_decl EQUAL expression
 //   | CONST variable_ident_decl EQUAL expression
-Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_stmt() {
+Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_statement() {
     if (match(Token::Type::kConst)) {
         auto decl = expect_variable_ident_decl("'const' declaration",
                                                /*allow_inferred = */ true);
@@ -1958,12 +1948,12 @@
     return create<ast::VariableDeclStatement>(var->source, var);
 }
 
-// if_stmt
+// if_statement
 //   : IF expression compound_stmt ( ELSE else_stmt ) ?
 // else_stmt
-//  : body_stmt
-//  | if_stmt
-Maybe<const ast::IfStatement*> ParserImpl::if_stmt() {
+//  : compound_statement
+//  | if_statement
+Maybe<const ast::IfStatement*> ParserImpl::if_statement() {
     // Parse if-else chains iteratively instead of recursively, to avoid
     // stack-overflow for long chains of if-else statements.
 
@@ -1988,7 +1978,7 @@
             return add_error(peek(), "unable to parse condition expression");
         }
 
-        auto body = expect_body_stmt();
+        auto body = expect_compound_statement();
         if (body.errored) {
             return Failure::kErrored;
         }
@@ -2024,7 +2014,7 @@
         }
 
         // If it wasn't an "else if", it must just be an "else".
-        auto else_body = expect_body_stmt();
+        auto else_body = expect_compound_statement();
         if (else_body.errored) {
             return Failure::kErrored;
         }
@@ -2040,9 +2030,9 @@
     return last_stmt->As<ast::IfStatement>();
 }
 
-// switch_stmt
+// switch_statement
 //   : SWITCH expression BRACKET_LEFT switch_body+ BRACKET_RIGHT
-Maybe<const ast::SwitchStatement*> ParserImpl::switch_stmt() {
+Maybe<const ast::SwitchStatement*> ParserImpl::switch_statement() {
     Source source;
     if (!match(Token::Type::kSwitch, &source)) {
         return Failure::kNoMatch;
@@ -2179,9 +2169,9 @@
     return create<ast::BlockStatement>(Source{}, stmts);
 }
 
-// loop_stmt
+// loop_statement
 //   : LOOP BRACKET_LEFT statements continuing_stmt? BRACKET_RIGHT
-Maybe<const ast::LoopStatement*> ParserImpl::loop_stmt() {
+Maybe<const ast::LoopStatement*> ParserImpl::loop_statement() {
     Source source;
     if (!match(Token::Type::kLoop, &source)) {
         return Failure::kNoMatch;
@@ -2210,10 +2200,10 @@
 
 ForHeader::~ForHeader() = default;
 
-// (variable_stmt | increment_stmt | decrement_stmt | assignment_stmt |
-// func_call_stmt)?
+// (variable_statement | increment_statement | decrement_statement | assignment_statement |
+// func_call_statement)?
 Maybe<const ast::Statement*> ParserImpl::for_header_initializer() {
-    auto call = func_call_stmt();
+    auto call = func_call_statement();
     if (call.errored) {
         return Failure::kErrored;
     }
@@ -2221,7 +2211,7 @@
         return call.value;
     }
 
-    auto var = variable_stmt();
+    auto var = variable_statement();
     if (var.errored) {
         return Failure::kErrored;
     }
@@ -2229,7 +2219,7 @@
         return var.value;
     }
 
-    auto assign = assignment_stmt();
+    auto assign = assignment_statement();
     if (assign.errored) {
         return Failure::kErrored;
     }
@@ -2240,9 +2230,9 @@
     return Failure::kNoMatch;
 }
 
-// (increment_stmt | decrement_stmt | assignment_stmt | func_call_stmt)?
+// (increment_statement | decrement_statement | assignment_statement | func_call_statement)?
 Maybe<const ast::Statement*> ParserImpl::for_header_continuing() {
-    auto call_stmt = func_call_stmt();
+    auto call_stmt = func_call_statement();
     if (call_stmt.errored) {
         return Failure::kErrored;
     }
@@ -2250,7 +2240,7 @@
         return call_stmt.value;
     }
 
-    auto assign = assignment_stmt();
+    auto assign = assignment_statement();
     if (assign.errored) {
         return Failure::kErrored;
     }
@@ -2262,10 +2252,10 @@
 }
 
 // for_header
-//   : (variable_stmt | assignment_stmt | func_call_stmt)?
+//   : (variable_statement | assignment_statement | func_call_statement)?
 //   SEMICOLON
 //      expression? SEMICOLON
-//      (assignment_stmt | func_call_stmt)?
+//      (assignment_statement | func_call_statement)?
 Expect<std::unique_ptr<ForHeader>> ParserImpl::expect_for_header() {
     auto initializer = for_header_initializer();
     if (initializer.errored) {
@@ -2295,7 +2285,7 @@
 
 // for_statement
 //   : FOR PAREN_LEFT for_header PAREN_RIGHT BRACE_LEFT statements BRACE_RIGHT
-Maybe<const ast::ForLoopStatement*> ParserImpl::for_stmt() {
+Maybe<const ast::ForLoopStatement*> ParserImpl::for_statement() {
     Source source;
     if (!match(Token::Type::kFor, &source)) {
         return Failure::kNoMatch;
@@ -2318,7 +2308,7 @@
 
 // while_statement
 //   :  WHILE expression compound_statement
-Maybe<const ast::WhileStatement*> ParserImpl::while_stmt() {
+Maybe<const ast::WhileStatement*> ParserImpl::while_statement() {
     Source source;
     if (!match(Token::Type::kWhile, &source)) {
         return Failure::kNoMatch;
@@ -2332,7 +2322,7 @@
         return add_error(peek(), "unable to parse while condition expression");
     }
 
-    auto body = expect_body_stmt();
+    auto body = expect_compound_statement();
     if (body.errored) {
         return Failure::kErrored;
     }
@@ -2340,9 +2330,9 @@
     return create<ast::WhileStatement>(source, condition.value, body.value);
 }
 
-// func_call_stmt
+// func_call_statement
 //    : IDENT argument_expression_list
-Maybe<const ast::CallStatement*> ParserImpl::func_call_stmt() {
+Maybe<const ast::CallStatement*> ParserImpl::func_call_statement() {
     auto& t = peek();
     auto& t2 = peek(1);
     if (!t.IsIdentifier() || !t2.Is(Token::Type::kParenLeft)) {
@@ -2364,9 +2354,9 @@
             std::move(params.value)));
 }
 
-// break_stmt
+// break_statement
 //   : BREAK
-Maybe<const ast::BreakStatement*> ParserImpl::break_stmt() {
+Maybe<const ast::BreakStatement*> ParserImpl::break_statement() {
     Source source;
     if (!match(Token::Type::kBreak, &source)) {
         return Failure::kNoMatch;
@@ -2375,9 +2365,9 @@
     return create<ast::BreakStatement>(source);
 }
 
-// continue_stmt
+// continue_statement
 //   : CONTINUE
-Maybe<const ast::ContinueStatement*> ParserImpl::continue_stmt() {
+Maybe<const ast::ContinueStatement*> ParserImpl::continue_statement() {
     Source source;
     if (!match(Token::Type::kContinue, &source)) {
         return Failure::kNoMatch;
@@ -2387,13 +2377,13 @@
 }
 
 // continuing_stmt
-//   : CONTINUING body_stmt
+//   : CONTINUING compound_statement
 Maybe<const ast::BlockStatement*> ParserImpl::continuing_stmt() {
     if (!match(Token::Type::kContinuing)) {
         return create<ast::BlockStatement>(Source{}, utils::Empty);
     }
 
-    return expect_body_stmt();
+    return expect_compound_statement();
 }
 
 // primary_expression
@@ -3088,16 +3078,16 @@
     return Failure::kNoMatch;
 }
 
-// assignment_stmt
+// assignment_statement
 // | lhs_expression ( equal | compound_assignment_operator ) expression
 // | underscore equal expression
 //
-// increment_stmt
+// increment_statement
 // | lhs_expression PLUS_PLUS
 //
-// decrement_stmt
+// decrement_statement
 // | lhs_expression MINUS_MINUS
-Maybe<const ast::Statement*> ParserImpl::assignment_stmt() {
+Maybe<const ast::Statement*> ParserImpl::assignment_statement() {
     auto& t = peek();
 
     // tint:295 - Test for `ident COLON` - this is invalid grammar, and without
diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h
index 40b7cc8..eb26a81 100644
--- a/src/tint/reader/wgsl/parser_impl.h
+++ b/src/tint/reader/wgsl/parser_impl.h
@@ -474,7 +474,7 @@
     Expect<ast::TexelFormat> expect_texel_format(std::string_view use);
     /// Parses a `static_assert_statement` grammar element
     /// @returns returns the static assert, if it matched.
-    Maybe<const ast::StaticAssert*> static_assert_stmt();
+    Maybe<const ast::StaticAssert*> static_assert_statement();
     /// Parses a `function_header` grammar element
     /// @returns the parsed function header
     Maybe<FunctionHeader> function_header();
@@ -505,9 +505,9 @@
     /// valid builtin name.
     /// @returns the parsed builtin.
     Expect<ast::BuiltinValue> expect_builtin();
-    /// Parses a `body_stmt` grammar element, erroring on parse failure.
+    /// Parses a `compound_statement` grammar element, erroring on parse failure.
     /// @returns the parsed statements
-    Expect<ast::BlockStatement*> expect_body_stmt();
+    Expect<ast::BlockStatement*> expect_compound_statement();
     /// Parses a `paren_expression` grammar element, erroring on parse failure.
     /// @returns the parsed element or nullptr
     Expect<const ast::Expression*> expect_paren_expression();
@@ -517,24 +517,24 @@
     /// Parses a `statement` grammar element
     /// @returns the parsed statement or nullptr
     Maybe<const ast::Statement*> statement();
-    /// Parses a `break_stmt` grammar element
+    /// Parses a `break_statement` grammar element
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::BreakStatement*> break_stmt();
-    /// Parses a `return_stmt` grammar element
+    Maybe<const ast::BreakStatement*> break_statement();
+    /// Parses a `return_statement` grammar element
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::ReturnStatement*> return_stmt();
-    /// Parses a `continue_stmt` grammar element
+    Maybe<const ast::ReturnStatement*> return_statement();
+    /// Parses a `continue_statement` grammar element
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::ContinueStatement*> continue_stmt();
-    /// Parses a `variable_stmt` grammar element
+    Maybe<const ast::ContinueStatement*> continue_statement();
+    /// Parses a `variable_statement` grammar element
     /// @returns the parsed variable or nullptr
-    Maybe<const ast::VariableDeclStatement*> variable_stmt();
-    /// Parses a `if_stmt` grammar element
+    Maybe<const ast::VariableDeclStatement*> variable_statement();
+    /// Parses a `if_statement` grammar element
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::IfStatement*> if_stmt();
-    /// Parses a `switch_stmt` grammar element
+    Maybe<const ast::IfStatement*> if_statement();
+    /// Parses a `switch_statement` grammar element
     /// @returns the parsed statement or nullptr
-    Maybe<const ast::SwitchStatement*> switch_stmt();
+    Maybe<const ast::SwitchStatement*> switch_statement();
     /// Parses a `switch_body` grammar element
     /// @returns the parsed statement or nullptr
     Maybe<const ast::CaseStatement*> switch_body();
@@ -544,21 +544,21 @@
     /// Parses a `case_body` grammar element
     /// @returns the parsed statements
     Maybe<const ast::BlockStatement*> case_body();
-    /// Parses a `func_call_stmt` grammar element
+    /// Parses a `func_call_statement` grammar element
     /// @returns the parsed function call or nullptr
-    Maybe<const ast::CallStatement*> func_call_stmt();
-    /// Parses a `loop_stmt` grammar element
+    Maybe<const ast::CallStatement*> func_call_statement();
+    /// Parses a `loop_statement` grammar element
     /// @returns the parsed loop or nullptr
-    Maybe<const ast::LoopStatement*> loop_stmt();
+    Maybe<const ast::LoopStatement*> loop_statement();
     /// Parses a `for_header` grammar element, erroring on parse failure.
     /// @returns the parsed for header or nullptr
     Expect<std::unique_ptr<ForHeader>> expect_for_header();
-    /// Parses a `for_stmt` grammar element
+    /// Parses a `for_statement` grammar element
     /// @returns the parsed for loop or nullptr
-    Maybe<const ast::ForLoopStatement*> for_stmt();
-    /// Parses a `while_stmt` grammar element
+    Maybe<const ast::ForLoopStatement*> for_statement();
+    /// Parses a `while_statement` grammar element
     /// @returns the parsed while loop or nullptr
-    Maybe<const ast::WhileStatement*> while_stmt();
+    Maybe<const ast::WhileStatement*> while_statement();
     /// Parses a `continuing_stmt` grammar element
     /// @returns the parsed statements
     Maybe<const ast::BlockStatement*> continuing_stmt();
@@ -669,9 +669,9 @@
     /// Parses a `compound_assignment_operator` grammar element
     /// @returns the parsed compound assignment operator
     Maybe<ast::BinaryOp> compound_assignment_operator();
-    /// Parses a `assignment_stmt` grammar element
+    /// Parses a `assignment_statement` grammar element
     /// @returns the parsed assignment or nullptr
-    Maybe<const ast::Statement*> assignment_stmt();
+    Maybe<const ast::Statement*> assignment_statement();
     /// Parses one or more attribute lists.
     /// @return the parsed attribute list, or an empty list on error.
     Maybe<AttributeList> attribute_list();
diff --git a/src/tint/reader/wgsl/parser_impl_assignment_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_assignment_stmt_test.cc
index 786e6ea..4581d98 100644
--- a/src/tint/reader/wgsl/parser_impl_assignment_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_assignment_stmt_test.cc
@@ -19,7 +19,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToVariable) {
     auto p = parser("a = 123");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -42,7 +42,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToMember) {
     auto p = parser("a.b.c[2].d = 123");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -92,7 +92,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToPhony) {
     auto p = parser("_ = 123i");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -119,7 +119,7 @@
 TEST_P(CompoundOpTest, CompoundOp) {
     auto params = GetParam();
     auto p = parser("a " + params.str + " 123u");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -155,7 +155,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_MissingEqual) {
     auto p = parser("a.b.c[2].d 123");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_TRUE(p->has_error());
@@ -165,7 +165,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_Compound_MissingEqual) {
     auto p = parser("a + 123");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_TRUE(p->has_error());
@@ -175,7 +175,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_InvalidLHS) {
     auto p = parser("if (true) {} = 123");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -184,7 +184,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_InvalidRHS) {
     auto p = parser("a.b.c[2].d = if (true) {}");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -194,7 +194,7 @@
 
 TEST_F(ParserImplTest, AssignmentStmt_InvalidCompoundOp) {
     auto p = parser("a &&= true");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_break_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_break_stmt_test.cc
index ca8802a..21c5267 100644
--- a/src/tint/reader/wgsl/parser_impl_break_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_break_stmt_test.cc
@@ -20,7 +20,7 @@
 
 TEST_F(ParserImplTest, BreakStmt) {
     auto p = parser("break");
-    auto e = p->break_stmt();
+    auto e = p->break_statement();
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_body_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_compound_stmt_test.cc
similarity index 80%
rename from src/tint/reader/wgsl/parser_impl_body_stmt_test.cc
rename to src/tint/reader/wgsl/parser_impl_compound_stmt_test.cc
index d6e8e64..947cb48 100644
--- a/src/tint/reader/wgsl/parser_impl_body_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_compound_stmt_test.cc
@@ -18,12 +18,12 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, BodyStmt) {
+TEST_F(ParserImplTest, CompoundStmt) {
     auto p = parser(R"({
   discard;
   return 1 + b / 2;
 })");
-    auto e = p->expect_body_stmt();
+    auto e = p->expect_compound_statement();
     ASSERT_FALSE(p->has_error()) << p->error();
     ASSERT_FALSE(e.errored);
     ASSERT_EQ(e->statements.Length(), 2u);
@@ -31,25 +31,25 @@
     EXPECT_TRUE(e->statements[1]->Is<ast::ReturnStatement>());
 }
 
-TEST_F(ParserImplTest, BodyStmt_Empty) {
+TEST_F(ParserImplTest, CompoundStmt_Empty) {
     auto p = parser("{}");
-    auto e = p->expect_body_stmt();
+    auto e = p->expect_compound_statement();
     ASSERT_FALSE(p->has_error()) << p->error();
     ASSERT_FALSE(e.errored);
     EXPECT_EQ(e->statements.Length(), 0u);
 }
 
-TEST_F(ParserImplTest, BodyStmt_InvalidStmt) {
+TEST_F(ParserImplTest, CompoundStmt_InvalidStmt) {
     auto p = parser("{fn main() {}}");
-    auto e = p->expect_body_stmt();
+    auto e = p->expect_compound_statement();
     ASSERT_TRUE(p->has_error());
     ASSERT_TRUE(e.errored);
     EXPECT_EQ(p->error(), "1:2: expected '}'");
 }
 
-TEST_F(ParserImplTest, BodyStmt_MissingRightParen) {
+TEST_F(ParserImplTest, CompoundStmt_MissingRightParen) {
     auto p = parser("{return;");
-    auto e = p->expect_body_stmt();
+    auto e = p->expect_compound_statement();
     ASSERT_TRUE(p->has_error());
     ASSERT_TRUE(e.errored);
     EXPECT_EQ(p->error(), "1:9: expected '}'");
diff --git a/src/tint/reader/wgsl/parser_impl_continue_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_continue_stmt_test.cc
index 002f638..349bf5e 100644
--- a/src/tint/reader/wgsl/parser_impl_continue_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_continue_stmt_test.cc
@@ -20,7 +20,7 @@
 
 TEST_F(ParserImplTest, ContinueStmt) {
     auto p = parser("continue");
-    auto e = p->continue_stmt();
+    auto e = p->continue_statement();
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
index ae682a6..a8d7873 100644
--- a/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
@@ -24,7 +24,7 @@
 // Test an empty for loop.
 TEST_F(ForStmtTest, Empty) {
     auto p = parser("for (;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -37,7 +37,7 @@
 // Test a for loop with non-empty body.
 TEST_F(ForStmtTest, Body) {
     auto p = parser("for (;;) { discard; }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -51,7 +51,7 @@
 // Test a for loop declaring a variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementDecl) {
     auto p = parser("for (var i: i32 ;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -68,7 +68,7 @@
 // statement.
 TEST_F(ForStmtTest, InitializerStatementDeclEqual) {
     auto p = parser("for (var i: i32 = 0 ;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -84,7 +84,7 @@
 // Test a for loop declaring a const variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementConstDecl) {
     auto p = parser("for (let i: i32 = 0 ;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -100,7 +100,7 @@
 // Test a for loop assigning a variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementAssignment) {
     auto p = parser("for (i = 0 ;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -113,7 +113,7 @@
 // Test a for loop incrementing a variable in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementIncrement) {
     auto p = parser("for (i++;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -126,7 +126,7 @@
 // Test a for loop calling a function in the initializer statement.
 TEST_F(ForStmtTest, InitializerStatementFuncCall) {
     auto p = parser("for (a(b,c) ;;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -139,7 +139,7 @@
 // Test a for loop with a break condition
 TEST_F(ForStmtTest, BreakCondition) {
     auto p = parser("for (; 0 == 1;) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -152,7 +152,7 @@
 // Test a for loop assigning a variable in the continuing statement.
 TEST_F(ForStmtTest, ContinuingAssignment) {
     auto p = parser("for (;; x = 2) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -165,7 +165,7 @@
 // Test a for loop with an increment statement as the continuing statement.
 TEST_F(ForStmtTest, ContinuingIncrement) {
     auto p = parser("for (;; x++) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -178,7 +178,7 @@
 // Test a for loop calling a function in the continuing statement.
 TEST_F(ForStmtTest, ContinuingFuncCall) {
     auto p = parser("for (;; a(b,c)) { }");
-    auto fl = p->for_stmt();
+    auto fl = p->for_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(fl.errored);
     ASSERT_TRUE(fl.matched);
@@ -192,7 +192,7 @@
   public:
     void TestForWithError(std::string for_str, std::string error_str) {
         auto p_for = parser(for_str);
-        auto e_for = p_for->for_stmt();
+        auto e_for = p_for->for_statement();
 
         EXPECT_FALSE(e_for.matched);
         EXPECT_TRUE(e_for.errored);
diff --git a/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
index ff57908..59e5ad3 100644
--- a/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
@@ -19,7 +19,7 @@
 
 TEST_F(ParserImplTest, IfStmt) {
     auto p = parser("if a == 4 { a = b; c = d; }");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -34,7 +34,7 @@
 
 TEST_F(ParserImplTest, IfStmt_WithElse) {
     auto p = parser("if a == 4 { a = b; c = d; } else if(c) { d = 2; } else {}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -57,7 +57,7 @@
 
 TEST_F(ParserImplTest, IfStmt_WithElse_WithParens) {
     auto p = parser("if(a==4) { a = b; c = d; } else if(c) { d = 2; } else {}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -80,7 +80,7 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidCondition) {
     auto p = parser("if a = 3 {}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -90,7 +90,7 @@
 
 TEST_F(ParserImplTest, IfStmt_MissingCondition) {
     auto p = parser("if {}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -100,7 +100,7 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidBody) {
     auto p = parser("if a { fn main() {}}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -110,7 +110,7 @@
 
 TEST_F(ParserImplTest, IfStmt_MissingBody) {
     auto p = parser("if a");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -120,7 +120,7 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidElseif) {
     auto p = parser("if a {} else if a { fn main() -> a{}}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -130,7 +130,7 @@
 
 TEST_F(ParserImplTest, IfStmt_InvalidElse) {
     auto p = parser("if a {} else { fn main() -> a{}}");
-    auto e = p->if_stmt();
+    auto e = p->if_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_increment_decrement_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_increment_decrement_stmt_test.cc
index 8041735..d4e52b2 100644
--- a/src/tint/reader/wgsl/parser_impl_increment_decrement_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_increment_decrement_stmt_test.cc
@@ -19,7 +19,7 @@
 
 TEST_F(ParserImplTest, IncrementDecrementStmt_Increment) {
     auto p = parser("a++");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -38,7 +38,7 @@
 
 TEST_F(ParserImplTest, IncrementDecrementStmt_Decrement) {
     auto p = parser("a--");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -57,7 +57,7 @@
 
 TEST_F(ParserImplTest, IncrementDecrementStmt_Parenthesized) {
     auto p = parser("(a)++");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -76,7 +76,7 @@
 
 TEST_F(ParserImplTest, IncrementDecrementStmt_ToMember) {
     auto p = parser("a.b.c[2].d++");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -121,7 +121,7 @@
 
 TEST_F(ParserImplTest, IncrementDecrementStmt_InvalidLHS) {
     auto p = parser("{}++");
-    auto e = p->assignment_stmt();
+    auto e = p->assignment_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
diff --git a/src/tint/reader/wgsl/parser_impl_loop_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_loop_stmt_test.cc
index 2c65d23..a3e51b4 100644
--- a/src/tint/reader/wgsl/parser_impl_loop_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_loop_stmt_test.cc
@@ -20,7 +20,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_BodyNoContinuing) {
     auto p = parser("loop { discard; }");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -34,7 +34,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_BodyWithContinuing) {
     auto p = parser("loop { discard; continuing { discard; }}");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -49,7 +49,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_NoBodyNoContinuing) {
     auto p = parser("loop { }");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -60,7 +60,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_NoBodyWithContinuing) {
     auto p = parser("loop { continuing { discard; }}");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -72,7 +72,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_MissingBracketLeft) {
     auto p = parser("loop discard; }");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -82,7 +82,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_MissingBracketRight) {
     auto p = parser("loop { discard; ");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -92,7 +92,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_InvalidStatements) {
     auto p = parser("loop { discard }");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -102,7 +102,7 @@
 
 TEST_F(ParserImplTest, LoopStmt_InvalidContinuing) {
     auto p = parser("loop { continuing { discard }}");
-    auto e = p->loop_stmt();
+    auto e = p->loop_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
index 45993c6..014d850 100644
--- a/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
@@ -22,7 +22,7 @@
   case 1: {}
   case 2: {}
 })");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -35,7 +35,7 @@
 
 TEST_F(ParserImplTest, SwitchStmt_Empty) {
     auto p = parser("switch a { }");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -50,7 +50,7 @@
   default: {}
   case 2: {}
 })");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -65,7 +65,7 @@
 
 TEST_F(ParserImplTest, SwitchStmt_WithParens) {
     auto p = parser("switch(a+b) { }");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -76,7 +76,7 @@
 
 TEST_F(ParserImplTest, SwitchStmt_InvalidExpression) {
     auto p = parser("switch a=b {}");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -86,7 +86,7 @@
 
 TEST_F(ParserImplTest, SwitchStmt_MissingExpression) {
     auto p = parser("switch {}");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -96,7 +96,7 @@
 
 TEST_F(ParserImplTest, SwitchStmt_MissingBracketLeft) {
     auto p = parser("switch a }");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -106,7 +106,7 @@
 
 TEST_F(ParserImplTest, SwitchStmt_MissingBracketRight) {
     auto p = parser("switch a {");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -118,7 +118,7 @@
     auto p = parser(R"(switch a {
   case: {}
 })");
-    auto e = p->switch_stmt();
+    auto e = p->switch_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_variable_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_variable_stmt_test.cc
index 21ab6a8..c370262 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_stmt_test.cc
@@ -19,7 +19,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl) {
     auto p = parser("var a : i32;");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -38,7 +38,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_WithInit) {
     auto p = parser("var a : i32 = 1;");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -58,7 +58,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
     auto p = parser("var a : i32 = if(a) {}");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -68,7 +68,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit) {
     auto p = parser("var a : array<i32> = array<i32>();");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -86,7 +86,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit_NoSpace) {
     auto p = parser("var a : array<i32>=array<i32>();");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -104,7 +104,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit) {
     auto p = parser("var a : vec2<i32> = vec2<i32>();");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -122,7 +122,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit_NoSpace) {
     auto p = parser("var a : vec2<i32>=vec2<i32>();");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -140,7 +140,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_Let) {
     auto p = parser("let a : i32 = 1");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -155,7 +155,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_Let_MissingEqual) {
     auto p = parser("let a : i32 1");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -165,7 +165,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_Let_MissingConstructor) {
     auto p = parser("let a : i32 =");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
@@ -175,7 +175,7 @@
 
 TEST_F(ParserImplTest, VariableStmt_Let_InvalidConstructor) {
     auto p = parser("let a : i32 = if (a) {}");
-    auto e = p->variable_stmt();
+    auto e = p->variable_statement();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc b/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
index be6a2bb..247f340 100644
--- a/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
@@ -24,7 +24,7 @@
 // Test an empty while loop.
 TEST_F(WhileStmtTest, Empty) {
     auto p = parser("while (true) { }");
-    auto wl = p->while_stmt();
+    auto wl = p->while_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -35,7 +35,7 @@
 // Test a while loop with non-empty body.
 TEST_F(WhileStmtTest, Body) {
     auto p = parser("while (true) { discard; }");
-    auto wl = p->while_stmt();
+    auto wl = p->while_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -47,7 +47,7 @@
 // Test a while loop with complex condition.
 TEST_F(WhileStmtTest, ComplexCondition) {
     auto p = parser("while ((a + 1 - 2) == 3) { }");
-    auto wl = p->while_stmt();
+    auto wl = p->while_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -58,7 +58,7 @@
 // Test a while loop with no brackets.
 TEST_F(WhileStmtTest, NoBrackets) {
     auto p = parser("while (a + 1 - 2) == 3 { }");
-    auto wl = p->while_stmt();
+    auto wl = p->while_statement();
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_FALSE(wl.errored);
     ASSERT_TRUE(wl.matched);
@@ -70,7 +70,7 @@
   public:
     void TestForWithError(std::string for_str, std::string error_str) {
         auto p_for = parser(for_str);
-        auto e_for = p_for->while_stmt();
+        auto e_for = p_for->while_statement();
 
         EXPECT_FALSE(e_for.matched);
         EXPECT_TRUE(e_for.errored);