diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 8283b45..d140e1e 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -1350,7 +1350,6 @@
     sources = [
       "reader/wgsl/lexer_test.cc",
       "reader/wgsl/parser_impl_additive_expression_test.cc",
-      "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_bitwise_expression_test.cc",
@@ -1367,10 +1366,8 @@
       "reader/wgsl/parser_impl_depth_texture_test.cc",
       "reader/wgsl/parser_impl_element_count_expression_test.cc",
       "reader/wgsl/parser_impl_enable_directive_test.cc",
-      "reader/wgsl/parser_impl_equality_expression_test.cc",
       "reader/wgsl/parser_impl_error_msg_test.cc",
       "reader/wgsl/parser_impl_error_resync_test.cc",
-      "reader/wgsl/parser_impl_exclusive_or_expression_test.cc",
       "reader/wgsl/parser_impl_expression_test.cc",
       "reader/wgsl/parser_impl_external_texture_test.cc",
       "reader/wgsl/parser_impl_for_stmt_test.cc",
@@ -1382,11 +1379,8 @@
       "reader/wgsl/parser_impl_global_decl_test.cc",
       "reader/wgsl/parser_impl_global_variable_decl_test.cc",
       "reader/wgsl/parser_impl_if_stmt_test.cc",
-      "reader/wgsl/parser_impl_inclusive_or_expression_test.cc",
       "reader/wgsl/parser_impl_increment_decrement_stmt_test.cc",
       "reader/wgsl/parser_impl_lhs_expression_test.cc",
-      "reader/wgsl/parser_impl_logical_and_expression_test.cc",
-      "reader/wgsl/parser_impl_logical_or_expression_test.cc",
       "reader/wgsl/parser_impl_loop_stmt_test.cc",
       "reader/wgsl/parser_impl_math_expression_test.cc",
       "reader/wgsl/parser_impl_multiplicative_expression_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 6703d65..5d77470 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -945,7 +945,6 @@
       reader/wgsl/lexer_test.cc
       reader/wgsl/parser_test.cc
       reader/wgsl/parser_impl_additive_expression_test.cc
-      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_bitwise_expression_test.cc
@@ -962,10 +961,8 @@
       reader/wgsl/parser_impl_depth_texture_test.cc
       reader/wgsl/parser_impl_element_count_expression_test.cc
       reader/wgsl/parser_impl_enable_directive_test.cc
-      reader/wgsl/parser_impl_equality_expression_test.cc
       reader/wgsl/parser_impl_error_msg_test.cc
       reader/wgsl/parser_impl_error_resync_test.cc
-      reader/wgsl/parser_impl_exclusive_or_expression_test.cc
       reader/wgsl/parser_impl_expression_test.cc
       reader/wgsl/parser_impl_external_texture_test.cc
       reader/wgsl/parser_impl_for_stmt_test.cc
@@ -977,11 +974,8 @@
       reader/wgsl/parser_impl_global_decl_test.cc
       reader/wgsl/parser_impl_global_variable_decl_test.cc
       reader/wgsl/parser_impl_if_stmt_test.cc
-      reader/wgsl/parser_impl_inclusive_or_expression_test.cc
       reader/wgsl/parser_impl_increment_decrement_stmt_test.cc
       reader/wgsl/parser_impl_lhs_expression_test.cc
-      reader/wgsl/parser_impl_logical_and_expression_test.cc
-      reader/wgsl/parser_impl_logical_or_expression_test.cc
       reader/wgsl/parser_impl_loop_stmt_test.cc
       reader/wgsl/parser_impl_math_expression_test.cc
       reader/wgsl/parser_impl_multiplicative_expression_test.cc
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index c49580c..f0c6a18 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -579,7 +579,7 @@
 
     const ast::Expression* initializer = nullptr;
     if (match(Token::Type::kEqual)) {
-        auto expr = expression();
+        auto expr = maybe_expression();
         if (expr.errored) {
             return Failure::kErrored;
         }
@@ -639,7 +639,7 @@
 
     const ast::Expression* initializer = nullptr;
     if (has_initializer) {
-        auto expr = expression();
+        auto expr = maybe_expression();
         if (expr.errored) {
             return Failure::kErrored;
         }
@@ -1426,7 +1426,7 @@
         return Failure::kNoMatch;
     }
 
-    auto condition = expression();
+    auto condition = maybe_expression();
     if (condition.errored) {
         return Failure::kErrored;
     }
@@ -1691,7 +1691,7 @@
 //   : PAREN_LEFT expression PAREN_RIGHT
 Expect<const ast::Expression*> ParserImpl::expect_paren_expression() {
     return expect_paren_block("", [&]() -> Expect<const ast::Expression*> {
-        auto expr = expression();
+        auto expr = maybe_expression();
         if (expr.errored) {
             return Failure::kErrored;
         }
@@ -1895,7 +1895,7 @@
         return create<ast::ReturnStatement>(source, nullptr);
     }
 
-    auto expr = expression();
+    auto expr = maybe_expression();
     if (expr.errored) {
         return Failure::kErrored;
     }
@@ -2018,7 +2018,7 @@
             return Failure::kNoMatch;
         }
 
-        auto condition = expression();
+        auto condition = maybe_expression();
         if (condition.errored) {
             return Failure::kErrored;
         }
@@ -2086,7 +2086,7 @@
         return Failure::kNoMatch;
     }
 
-    auto condition = expression();
+    auto condition = maybe_expression();
     if (condition.errored) {
         return Failure::kErrored;
     }
@@ -2319,7 +2319,7 @@
         return Failure::kErrored;
     }
 
-    auto condition = expression();
+    auto condition = maybe_expression();
     if (condition.errored) {
         return Failure::kErrored;
     }
@@ -2367,7 +2367,7 @@
         return Failure::kNoMatch;
     }
 
-    auto condition = expression();
+    auto condition = maybe_expression();
     if (condition.errored) {
         return Failure::kErrored;
     }
@@ -2601,7 +2601,7 @@
     while (continue_parsing()) {
         if (match(Token::Type::kBracketLeft, &source)) {
             auto res = sync(Token::Type::kBracketRight, [&]() -> Maybe<const ast::Expression*> {
-                auto param = expression();
+                auto param = maybe_expression();
                 if (param.errored) {
                     return Failure::kErrored;
                 }
@@ -2649,7 +2649,7 @@
     return expect_paren_block(use, [&]() -> Expect<ExpressionList> {
         ExpressionList ret;
         while (continue_parsing()) {
-            auto arg = expression();
+            auto arg = maybe_expression();
             if (arg.errored) {
                 return Failure::kErrored;
             } else if (!arg.matched) {
@@ -2913,12 +2913,13 @@
             name = ">>";
         }
 
+        auto& rhs_start = peek();
         auto rhs = unary_expression();
         if (rhs.errored) {
             return Failure::kErrored;
         }
         if (!rhs.matched) {
-            return add_error(t,
+            return add_error(rhs_start,
                              std::string("unable to parse right side of ") + name + " expression");
         }
         return create<ast::BinaryExpression>(t.source(), op, lhs, rhs.value);
@@ -3044,7 +3045,7 @@
             }
             next();
 
-            auto rhs = relational_expression();
+            auto rhs = maybe_relational_expression();
             if (rhs.errored) {
                 return Failure::kErrored;
             }
@@ -3130,437 +3131,6 @@
     return create<ast::UnaryOpExpression>(t.source(), op, expr.value);
 }
 
-// multiplicative_expr
-//   :
-//   | STAR unary_expression multiplicative_expr
-//   | FORWARD_SLASH unary_expression multiplicative_expr
-//   | MODULO unary_expression multiplicative_expr
-Expect<const ast::Expression*> ParserImpl::expect_multiplicative_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        ast::BinaryOp op = ast::BinaryOp::kNone;
-        if (peek_is(Token::Type::kStar)) {
-            op = ast::BinaryOp::kMultiply;
-        } else if (peek_is(Token::Type::kForwardSlash)) {
-            op = ast::BinaryOp::kDivide;
-        } else if (peek_is(Token::Type::kMod)) {
-            op = ast::BinaryOp::kModulo;
-        } else {
-            return lhs;
-        }
-
-        auto& t = next();
-
-        auto rhs = unary_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of " + std::string(t.to_name()) +
-                                         " expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(t.source(), op, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// multiplicative_expression
-//   : unary_expression multiplicative_expr
-Maybe<const ast::Expression*> ParserImpl::multiplicative_expression() {
-    auto lhs = unary_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_multiplicative_expr(lhs.value);
-}
-
-// additive_expr
-//   :
-//   | PLUS multiplicative_expression additive_expr
-//   | MINUS multiplicative_expression additive_expr
-Expect<const ast::Expression*> ParserImpl::expect_additive_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        ast::BinaryOp op = ast::BinaryOp::kNone;
-        if (peek_is(Token::Type::kPlus)) {
-            op = ast::BinaryOp::kAdd;
-        } else if (peek_is(Token::Type::kMinus)) {
-            op = ast::BinaryOp::kSubtract;
-        } else {
-            return lhs;
-        }
-
-        auto& t = next();
-
-        auto rhs = multiplicative_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of + expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(t.source(), op, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// additive_expression
-//   : multiplicative_expression additive_expr
-Maybe<const ast::Expression*> ParserImpl::additive_expression() {
-    auto lhs = multiplicative_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_additive_expr(lhs.value);
-}
-
-// shift_expr
-//   :
-//   | SHIFT_LEFT additive_expression shift_expr
-//   | SHIFT_RIGHT additive_expression shift_expr
-Expect<const ast::Expression*> ParserImpl::expect_shift_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        auto* name = "";
-        ast::BinaryOp op = ast::BinaryOp::kNone;
-        if (peek_is(Token::Type::kShiftLeft)) {
-            op = ast::BinaryOp::kShiftLeft;
-            name = "<<";
-        } else if (peek_is(Token::Type::kShiftRight)) {
-            op = ast::BinaryOp::kShiftRight;
-            name = ">>";
-        } else {
-            return lhs;
-        }
-
-        auto& t = next();
-        auto rhs = additive_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(),
-                             std::string("unable to parse right side of ") + name + " expression");
-        }
-
-        return lhs = create<ast::BinaryExpression>(t.source(), op, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// shift_expression
-//   : additive_expression shift_expr
-Maybe<const ast::Expression*> ParserImpl::shift_expression() {
-    auto lhs = additive_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_shift_expr(lhs.value);
-}
-
-// relational_expr
-//   :
-//   | LESS_THAN shift_expression relational_expr
-//   | GREATER_THAN shift_expression relational_expr
-//   | LESS_THAN_EQUAL shift_expression relational_expr
-//   | GREATER_THAN_EQUAL shift_expression relational_expr
-Expect<const ast::Expression*> ParserImpl::expect_relational_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        ast::BinaryOp op = ast::BinaryOp::kNone;
-        if (peek_is(Token::Type::kLessThan)) {
-            op = ast::BinaryOp::kLessThan;
-        } else if (peek_is(Token::Type::kGreaterThan)) {
-            op = ast::BinaryOp::kGreaterThan;
-        } else if (peek_is(Token::Type::kLessThanEqual)) {
-            op = ast::BinaryOp::kLessThanEqual;
-        } else if (peek_is(Token::Type::kGreaterThanEqual)) {
-            op = ast::BinaryOp::kGreaterThanEqual;
-        } else {
-            return lhs;
-        }
-
-        auto& t = next();
-
-        auto rhs = shift_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of " + std::string(t.to_name()) +
-                                         " expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(t.source(), op, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// relational_expression
-//   : shift_expression relational_expr
-Maybe<const ast::Expression*> ParserImpl::relational_expression() {
-    auto lhs = shift_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_relational_expr(lhs.value);
-}
-
-// equality_expr
-//   :
-//   | EQUAL_EQUAL relational_expression equality_expr
-//   | NOT_EQUAL relational_expression equality_expr
-Expect<const ast::Expression*> ParserImpl::expect_equality_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        ast::BinaryOp op = ast::BinaryOp::kNone;
-        if (peek_is(Token::Type::kEqualEqual)) {
-            op = ast::BinaryOp::kEqual;
-        } else if (peek_is(Token::Type::kNotEqual)) {
-            op = ast::BinaryOp::kNotEqual;
-        } else {
-            return lhs;
-        }
-
-        auto& t = next();
-
-        auto rhs = relational_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of " + std::string(t.to_name()) +
-                                         " expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(t.source(), op, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// equality_expression
-//   : relational_expression equality_expr
-Maybe<const ast::Expression*> ParserImpl::equality_expression() {
-    auto lhs = relational_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_equality_expr(lhs.value);
-}
-
-// and_expr
-//   :
-//   | AND equality_expression and_expr
-Expect<const ast::Expression*> ParserImpl::expect_and_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        if (!peek_is(Token::Type::kAnd)) {
-            return lhs;
-        }
-
-        auto& t = next();
-
-        auto rhs = equality_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of & expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(t.source(), ast::BinaryOp::kAnd, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// and_expression
-//   : equality_expression and_expr
-Maybe<const ast::Expression*> ParserImpl::and_expression() {
-    auto lhs = equality_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_and_expr(lhs.value);
-}
-
-// exclusive_or_expr
-//   :
-//   | XOR and_expression exclusive_or_expr
-Expect<const ast::Expression*> ParserImpl::expect_exclusive_or_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        Source source;
-        if (!match(Token::Type::kXor, &source)) {
-            return lhs;
-        }
-
-        auto rhs = and_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of ^ expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(source, ast::BinaryOp::kXor, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// exclusive_or_expression
-//   : and_expression exclusive_or_expr
-Maybe<const ast::Expression*> ParserImpl::exclusive_or_expression() {
-    auto lhs = and_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_exclusive_or_expr(lhs.value);
-}
-
-// inclusive_or_expr
-//   :
-//   | OR exclusive_or_expression inclusive_or_expr
-Expect<const ast::Expression*> ParserImpl::expect_inclusive_or_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        Source source;
-        if (!match(Token::Type::kOr, &source)) {
-            return lhs;
-        }
-
-        auto rhs = exclusive_or_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of | expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(source, ast::BinaryOp::kOr, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// inclusive_or_expression
-//   : exclusive_or_expression inclusive_or_expr
-Maybe<const ast::Expression*> ParserImpl::inclusive_or_expression() {
-    auto lhs = exclusive_or_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_inclusive_or_expr(lhs.value);
-}
-
-// logical_and_expr
-//   :
-//   | AND_AND inclusive_or_expression logical_and_expr
-Expect<const ast::Expression*> ParserImpl::expect_logical_and_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        if (!peek_is(Token::Type::kAndAnd)) {
-            return lhs;
-        }
-
-        auto& t = next();
-
-        auto rhs = inclusive_or_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of && expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(t.source(), ast::BinaryOp::kLogicalAnd, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// logical_and_expression
-//   : inclusive_or_expression logical_and_expr
-Maybe<const ast::Expression*> ParserImpl::logical_and_expression() {
-    auto lhs = inclusive_or_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_logical_and_expr(lhs.value);
-}
-
-// logical_or_expr
-//   :
-//   | OR_OR logical_and_expression logical_or_expr
-Expect<const ast::Expression*> ParserImpl::expect_logical_or_expr(const ast::Expression* lhs) {
-    while (continue_parsing()) {
-        Source source;
-        if (!match(Token::Type::kOrOr, &source)) {
-            return lhs;
-        }
-
-        auto rhs = logical_and_expression();
-        if (rhs.errored) {
-            return Failure::kErrored;
-        }
-        if (!rhs.matched) {
-            return add_error(peek(), "unable to parse right side of || expression");
-        }
-
-        lhs = create<ast::BinaryExpression>(source, ast::BinaryOp::kLogicalOr, lhs, rhs.value);
-    }
-    return Failure::kErrored;
-}
-
-// logical_or_expression
-//   : logical_and_expression logical_or_expr
-Maybe<const ast::Expression*> ParserImpl::logical_or_expression() {
-    auto lhs = logical_and_expression();
-    if (lhs.errored) {
-        return Failure::kErrored;
-    }
-    if (!lhs.matched) {
-        return Failure::kNoMatch;
-    }
-
-    return expect_logical_or_expr(lhs.value);
-}
-
-// expression:
-//   : relational_expression
-//   | short_circuit_or_expression or_or relational_expression
-//   | short_circuit_and_expression and_and relational_expression
-//   | bitwise_expression
-Maybe<const ast::Expression*> ParserImpl::expression() {
-    return logical_or_expression();
-}
-
 // compound_assignment_operator
 //   : plus_equal
 //   | minus_equal
@@ -3735,7 +3305,7 @@
         }
     }
 
-    auto rhs = expression();
+    auto rhs = maybe_expression();
     if (rhs.errored) {
         return Failure::kErrored;
     }
diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h
index 44525c0..c733d02 100644
--- a/src/tint/reader/wgsl/parser_impl.h
+++ b/src/tint/reader/wgsl/parser_impl.h
@@ -621,49 +621,9 @@
     /// Parses a `unary_expression` grammar element
     /// @returns the parsed expression or nullptr
     Maybe<const ast::Expression*> unary_expression();
-    /// Parses the recursive part of the `multiplicative_expression`, erroring on
-    /// parse failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_multiplicative_expr(const ast::Expression* lhs);
-    /// Parses the `multiplicative_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> multiplicative_expression();
-    /// Parses the recursive part of the `additive_expression`, erroring on parse
-    /// failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_additive_expr(const ast::Expression* lhs);
-    /// Parses the `additive_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> additive_expression();
-    /// Parses the recursive part of the `shift_expression`, erroring on parse
-    /// failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_shift_expr(const ast::Expression* lhs);
-    /// Parses the `shift_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> shift_expression();
-    /// Parses the recursive part of the `relational_expression`, erroring on
-    /// parse failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_relational_expr(const ast::Expression* lhs);
     /// Parses the `expression` grammar rule
     /// @returns the parsed expression or nullptr
     Maybe<const ast::Expression*> maybe_expression();
-    /// Parses the `relational_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> relational_expression();
-    /// Parses the recursive part of the `equality_expression`, erroring on parse
-    /// failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_equality_expr(const ast::Expression* lhs);
-    /// Parses the `equality_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> equality_expression();
     /// Parses the `bitwise_expression.post.unary_expression` grammar element
     /// @param lhs the left side of the expression
     /// @returns the parsed expression or nullptr
@@ -709,49 +669,6 @@
     /// Parse the `additive_operator` grammar element
     /// @returns the parsed operator if successful
     Maybe<ast::BinaryOp> additive_operator();
-    /// Parses the recursive part of the `and_expression`, erroring on parse
-    /// failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_and_expr(const ast::Expression* lhs);
-    /// Parses the `and_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> and_expression();
-    /// Parses the recursive part of the `exclusive_or_expression`, erroring on
-    /// parse failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_exclusive_or_expr(const ast::Expression* lhs);
-    /// Parses the `exclusive_or_expression` grammar elememnt
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> exclusive_or_expression();
-    /// Parses the recursive part of the `inclusive_or_expression`, erroring on
-    /// parse failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_inclusive_or_expr(const ast::Expression* lhs);
-    /// Parses the `inclusive_or_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> inclusive_or_expression();
-    /// Parses the recursive part of the `logical_and_expression`, erroring on
-    /// parse failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_logical_and_expr(const ast::Expression* lhs);
-    /// Parses a `logical_and_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> logical_and_expression();
-    /// Parses the recursive part of the `logical_or_expression`, erroring on
-    /// parse failure.
-    /// @param lhs the left side of the expression
-    /// @returns the parsed expression or nullptr
-    Expect<const ast::Expression*> expect_logical_or_expr(const ast::Expression* lhs);
-    /// Parses a `logical_or_expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> logical_or_expression();
-    /// Parses an `expression` grammar element
-    /// @returns the parsed expression or nullptr
-    Maybe<const ast::Expression*> expression();
     /// Parses a `compound_assignment_operator` grammar element
     /// @returns the parsed compound assignment operator
     Maybe<ast::BinaryOp> compound_assignment_operator();
diff --git a/src/tint/reader/wgsl/parser_impl_additive_expression_test.cc b/src/tint/reader/wgsl/parser_impl_additive_expression_test.cc
index 3259e27..971c695 100644
--- a/src/tint/reader/wgsl/parser_impl_additive_expression_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_additive_expression_test.cc
@@ -17,80 +17,6 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, AdditiveExpression_Orig_Parses_Plus) {
-    auto p = parser("a + true");
-    auto e = p->additive_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kAdd, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, AdditiveExpression_Orig_Parses_Minus) {
-    auto p = parser("a - true");
-    auto e = p->additive_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kSubtract, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, AdditiveExpression_Orig_InvalidLHS) {
-    auto p = parser("if (a) {} + true");
-    auto e = p->additive_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, AdditiveExpression_Orig_InvalidRHS) {
-    auto p = parser("true + if (a) {}");
-    auto e = p->additive_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:8: unable to parse right side of + expression");
-}
-
-TEST_F(ParserImplTest, AdditiveExpression_Orig_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->additive_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
 TEST_F(ParserImplTest, AdditiveExpression_Parses_Plus) {
     auto p = parser("a + b");
     auto lhs = p->unary_expression();
diff --git a/src/tint/reader/wgsl/parser_impl_and_expression_test.cc b/src/tint/reader/wgsl/parser_impl_and_expression_test.cc
deleted file mode 100644
index fd90460..0000000
--- a/src/tint/reader/wgsl/parser_impl_and_expression_test.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint::reader::wgsl {
-namespace {
-
-TEST_F(ParserImplTest, AndExpression_Parses) {
-    auto p = parser("a & true");
-    auto e = p->and_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kAnd, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, AndExpression_InvalidLHS) {
-    auto p = parser("if (a) {} & true");
-    auto e = p->and_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, AndExpression_InvalidRHS) {
-    auto p = parser("true & if (a) {}");
-    auto e = p->and_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:8: unable to parse right side of & expression");
-}
-
-TEST_F(ParserImplTest, AndExpression_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->and_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
-}  // namespace
-}  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_equality_expression_test.cc b/src/tint/reader/wgsl/parser_impl_equality_expression_test.cc
deleted file mode 100644
index 158227d..0000000
--- a/src/tint/reader/wgsl/parser_impl_equality_expression_test.cc
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint::reader::wgsl {
-namespace {
-
-TEST_F(ParserImplTest, EqualityExpression_Parses_Equal) {
-    auto p = parser("a == true");
-    auto e = p->equality_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kEqual, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, EqualityExpression_Parses_NotEqual) {
-    auto p = parser("a != true");
-    auto e = p->equality_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kNotEqual, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, EqualityExpression_InvalidLHS) {
-    auto p = parser("if (a) {} == true");
-    auto e = p->equality_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, EqualityExpression_InvalidRHS) {
-    auto p = parser("true == if (a) {}");
-    auto e = p->equality_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:9: unable to parse right side of == expression");
-}
-
-TEST_F(ParserImplTest, EqualityExpression_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->equality_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
-}  // namespace
-}  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_exclusive_or_expression_test.cc b/src/tint/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
deleted file mode 100644
index 2994ae8..0000000
--- a/src/tint/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint::reader::wgsl {
-namespace {
-
-TEST_F(ParserImplTest, ExclusiveOrExpression_Parses) {
-    auto p = parser("a ^ true");
-    auto e = p->exclusive_or_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kXor, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, ExclusiveOrExpression_InvalidLHS) {
-    auto p = parser("if (a) {} ^ true");
-    auto e = p->exclusive_or_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, ExclusiveOrExpression_InvalidRHS) {
-    auto p = parser("true ^ if (a) {}");
-    auto e = p->exclusive_or_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    ASSERT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:8: unable to parse right side of ^ expression");
-}
-
-TEST_F(ParserImplTest, ExclusiveOrExpression_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->exclusive_or_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
-}  // namespace
-}  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_inclusive_or_expression_test.cc b/src/tint/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
deleted file mode 100644
index f534ff7..0000000
--- a/src/tint/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint::reader::wgsl {
-namespace {
-
-TEST_F(ParserImplTest, InclusiveOrExpression_Parses) {
-    auto p = parser("a | true");
-    auto e = p->inclusive_or_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kOr, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, InclusiveOrExpression_InvalidLHS) {
-    auto p = parser("if (a) {} | true");
-    auto e = p->inclusive_or_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, InclusiveOrExpression_InvalidRHS) {
-    auto p = parser("true | if (a) {}");
-    auto e = p->inclusive_or_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:8: unable to parse right side of | expression");
-}
-
-TEST_F(ParserImplTest, InclusiveOrExpression_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->inclusive_or_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
-}  // namespace
-}  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_logical_and_expression_test.cc b/src/tint/reader/wgsl/parser_impl_logical_and_expression_test.cc
deleted file mode 100644
index 8baadaf..0000000
--- a/src/tint/reader/wgsl/parser_impl_logical_and_expression_test.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint::reader::wgsl {
-namespace {
-
-TEST_F(ParserImplTest, LogicalAndExpression_Parses) {
-    auto p = parser("a && true");
-    auto e = p->logical_and_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, LogicalAndExpression_InvalidLHS) {
-    auto p = parser("if (a) {} && true");
-    auto e = p->logical_and_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, LogicalAndExpression_InvalidRHS) {
-    auto p = parser("true && if (a) {}");
-    auto e = p->logical_and_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:9: unable to parse right side of && expression");
-}
-
-TEST_F(ParserImplTest, LogicalAndExpression_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->logical_and_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
-}  // namespace
-}  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_logical_or_expression_test.cc b/src/tint/reader/wgsl/parser_impl_logical_or_expression_test.cc
deleted file mode 100644
index 943b059..0000000
--- a/src/tint/reader/wgsl/parser_impl_logical_or_expression_test.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint::reader::wgsl {
-namespace {
-
-TEST_F(ParserImplTest, LogicalOrExpression_Parses) {
-    auto p = parser("a || true");
-    auto e = p->logical_or_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, LogicalOrExpression_InvalidLHS) {
-    auto p = parser("if (a) {} || true");
-    auto e = p->logical_or_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, LogicalOrExpression_InvalidRHS) {
-    auto p = parser("true || if (a) {}");
-    auto e = p->logical_or_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:9: unable to parse right side of || expression");
-}
-
-TEST_F(ParserImplTest, LogicalOrExpression_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->logical_or_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
-}  // namespace
-}  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_multiplicative_expression_test.cc b/src/tint/reader/wgsl/parser_impl_multiplicative_expression_test.cc
index 618a0c0..9417477 100644
--- a/src/tint/reader/wgsl/parser_impl_multiplicative_expression_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_multiplicative_expression_test.cc
@@ -17,100 +17,6 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, MultiplicativeExpression_Orig_Parses_Multiply) {
-    auto p = parser("a * true");
-    auto e = p->multiplicative_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kMultiply, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, MultiplicativeExpression_Orig_Parses_Divide) {
-    auto p = parser("a / true");
-    auto e = p->multiplicative_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kDivide, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, MultiplicativeExpression_Orig_Parses_Modulo) {
-    auto p = parser("a % true");
-    auto e = p->multiplicative_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kModulo, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, MultiplicativeExpression_Orig_InvalidLHS) {
-    auto p = parser("if (a) {} * true");
-    auto e = p->multiplicative_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, MultiplicativeExpression_Orig_InvalidRHS) {
-    auto p = parser("true * if (a) {}");
-    auto e = p->multiplicative_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_EQ(e.value, nullptr);
-    ASSERT_TRUE(p->has_error());
-    EXPECT_EQ(p->error(), "1:8: unable to parse right side of * expression");
-}
-
-TEST_F(ParserImplTest, MultiplicativeExpression_Orig_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->multiplicative_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
 TEST_F(ParserImplTest, MultiplicativeExpression_Parses_Multiply) {
     auto p = parser("a * b");
     auto lhs = p->unary_expression();
diff --git a/src/tint/reader/wgsl/parser_impl_relational_expression_test.cc b/src/tint/reader/wgsl/parser_impl_relational_expression_test.cc
index 59cddc6..0d0eabc 100644
--- a/src/tint/reader/wgsl/parser_impl_relational_expression_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_relational_expression_test.cc
@@ -17,133 +17,6 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, RelationalExpression_Orig_Parses_LessThan) {
-    auto p = parser("a < true");
-    auto e = p->relational_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kLessThan, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, RelationalExpression_Orig_Parses_GreaterThan) {
-    auto p = parser("a > true");
-    auto e = p->relational_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 4u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kGreaterThan, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, RelationalExpression_Orig_Parses_LessThanEqual) {
-    auto p = parser("a <= true");
-    auto e = p->relational_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kLessThanEqual, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, RelationalExpression_Orig_Parses_GreaterThanEqual) {
-    auto p = parser("a >= true");
-    auto e = p->relational_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kGreaterThanEqual, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Register("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, RelationalExpression_Orig_InvalidLHS) {
-    auto p = parser("if (a) {} < true");
-    auto e = p->relational_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, RelationalExpression_Orig_InvalidRHS) {
-    auto p = parser("true < if (a) {}");
-    auto e = p->relational_expression();
-    ASSERT_TRUE(p->has_error());
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_EQ(p->error(), "1:8: unable to parse right side of < expression");
-}
-
-TEST_F(ParserImplTest, RelationalExpression_Orig_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->relational_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
 TEST_F(ParserImplTest, RelationalExpression_PostUnary_Parses_LessThan) {
     auto p = parser("a < true");
     auto lhs = p->unary_expression();
@@ -352,5 +225,65 @@
     EXPECT_EQ(p->error(), "1:8: unable to parse right side of < expression");
 }
 
+TEST_F(ParserImplTest, RelationalExpression_Parses_Equal) {
+    auto p = parser("a == true");
+    auto e = p->maybe_relational_expression();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    ASSERT_NE(e.value, nullptr);
+
+    EXPECT_EQ(e->source.range.begin.line, 1u);
+    EXPECT_EQ(e->source.range.begin.column, 3u);
+    EXPECT_EQ(e->source.range.end.line, 1u);
+    EXPECT_EQ(e->source.range.end.column, 5u);
+
+    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+    auto* rel = e->As<ast::BinaryExpression>();
+    EXPECT_EQ(ast::BinaryOp::kEqual, rel->op);
+
+    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
+    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
+    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
+
+    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
+    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
+}
+
+TEST_F(ParserImplTest, RelationalExpression_Parses_NotEqual) {
+    auto p = parser("a != true");
+    auto e = p->maybe_relational_expression();
+    EXPECT_TRUE(e.matched);
+    EXPECT_FALSE(e.errored);
+    EXPECT_FALSE(p->has_error()) << p->error();
+    ASSERT_NE(e.value, nullptr);
+
+    EXPECT_EQ(e->source.range.begin.line, 1u);
+    EXPECT_EQ(e->source.range.begin.column, 3u);
+    EXPECT_EQ(e->source.range.end.line, 1u);
+    EXPECT_EQ(e->source.range.end.column, 5u);
+
+    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
+    auto* rel = e->As<ast::BinaryExpression>();
+    EXPECT_EQ(ast::BinaryOp::kNotEqual, rel->op);
+
+    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
+    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
+    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
+
+    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
+    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
+}
+
+TEST_F(ParserImplTest, RelationalExpression_Equal_InvalidRHS) {
+    auto p = parser("true == if (a) {}");
+    auto e = p->maybe_relational_expression();
+    EXPECT_FALSE(e.matched);
+    EXPECT_TRUE(e.errored);
+    EXPECT_EQ(e.value, nullptr);
+    EXPECT_TRUE(p->has_error());
+    EXPECT_EQ(p->error(), "1:9: unable to parse right side of == expression");
+}
+
 }  // namespace
 }  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_shift_expression_test.cc b/src/tint/reader/wgsl/parser_impl_shift_expression_test.cc
index d518004..2c8aef3 100644
--- a/src/tint/reader/wgsl/parser_impl_shift_expression_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_shift_expression_test.cc
@@ -17,103 +17,6 @@
 namespace tint::reader::wgsl {
 namespace {
 
-TEST_F(ParserImplTest, ShiftExpression_Orig_Parses_ShiftLeft) {
-    auto p = parser("a << true");
-    auto e = p->shift_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kShiftLeft, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, ShiftExpression_Orig_Parses_ShiftRight) {
-    auto p = parser("a >> true");
-    auto e = p->shift_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-
-    EXPECT_EQ(e->source.range.begin.line, 1u);
-    EXPECT_EQ(e->source.range.begin.column, 3u);
-    EXPECT_EQ(e->source.range.end.line, 1u);
-    EXPECT_EQ(e->source.range.end.column, 5u);
-
-    ASSERT_TRUE(e->Is<ast::BinaryExpression>());
-    auto* rel = e->As<ast::BinaryExpression>();
-    EXPECT_EQ(ast::BinaryOp::kShiftRight, rel->op);
-
-    ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
-    auto* ident = rel->lhs->As<ast::IdentifierExpression>();
-    EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));
-
-    ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
-    ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
-}
-
-TEST_F(ParserImplTest, ShiftExpression_Orig_InvalidSpaceLeft) {
-    auto p = parser("a < < true");
-    auto e = p->shift_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    ASSERT_NE(e.value, nullptr);
-    EXPECT_FALSE(e.value->Is<ast::BinaryExpression>());
-}
-
-TEST_F(ParserImplTest, ShiftExpression_Orig_InvalidSpaceRight) {
-    auto p = parser("a > > true");
-    auto e = p->shift_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    ASSERT_NE(e.value, nullptr);
-    EXPECT_FALSE(e.value->Is<ast::BinaryExpression>());
-}
-
-TEST_F(ParserImplTest, ShiftExpression_Orig_InvalidLHS) {
-    auto p = parser("if (a) {} << true");
-    auto e = p->shift_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    EXPECT_EQ(e.value, nullptr);
-}
-
-TEST_F(ParserImplTest, ShiftExpression_Orig_InvalidRHS) {
-    auto p = parser("true << if (a) {}");
-    auto e = p->shift_expression();
-    EXPECT_FALSE(e.matched);
-    EXPECT_TRUE(e.errored);
-    EXPECT_TRUE(p->has_error());
-    EXPECT_EQ(e.value, nullptr);
-    EXPECT_EQ(p->error(), "1:9: unable to parse right side of << expression");
-}
-
-TEST_F(ParserImplTest, ShiftExpression_Orig_NoOr_ReturnsLHS) {
-    auto p = parser("a true");
-    auto e = p->shift_expression();
-    EXPECT_TRUE(e.matched);
-    EXPECT_FALSE(e.errored);
-    EXPECT_FALSE(p->has_error()) << p->error();
-    ASSERT_NE(e.value, nullptr);
-    ASSERT_TRUE(e->Is<ast::IdentifierExpression>());
-}
-
 TEST_F(ParserImplTest, ShiftExpression_PostUnary_Parses_ShiftLeft) {
     auto p = parser("a << true");
     auto lhs = p->unary_expression();
@@ -231,7 +134,7 @@
     EXPECT_TRUE(e.errored);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(e.value, nullptr);
-    EXPECT_EQ(p->error(), "1:3: unable to parse right side of << expression");
+    EXPECT_EQ(p->error(), "1:6: unable to parse right side of << expression");
 }
 
 TEST_F(ParserImplTest, ShiftExpression_PostUnary_NoOr_ReturnsLHS) {
diff --git a/src/tint/reader/wgsl/parser_impl_unary_expression_test.cc b/src/tint/reader/wgsl/parser_impl_unary_expression_test.cc
index 184de66..29598d9 100644
--- a/src/tint/reader/wgsl/parser_impl_unary_expression_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_unary_expression_test.cc
@@ -86,7 +86,7 @@
 
 TEST_F(ParserImplTest, UnaryExpression_AddressOf_Precedence) {
     auto p = parser("&x.y");
-    auto e = p->logical_or_expression();
+    auto e = p->unary_expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
@@ -100,7 +100,7 @@
 
 TEST_F(ParserImplTest, UnaryExpression_Dereference_Precedence) {
     auto p = parser("*x.y");
-    auto e = p->logical_or_expression();
+    auto e = p->unary_expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();