Convert to new expression grammar
This CL moves all the grammar rules to use the new
`maybe_expression` rules. All of the old `expression` rules
are removed.
Bug: tint:1633
Change-Id: I29637a4c6fcd200650a2b57011b6539c66be942a
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/99920
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
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();
