encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Sync the `statement` grammar element. 

This CL updates a few names in the statement element to match the
spec. The `body_stmt` is now `compound_statement`.

Bug: tint:1633
Change-Id: I23a622fc8587641d3b6c5ff2641f29a3471fa4e1
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/98280
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
dan sinclair 2022-08-05 14:53:47 +00:00 committed by Dawn LUCI CQ
parent 7d8307122e
commit 1cd4706f85
15 changed files with 190 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/tint/BUILD.gn
View File

@ -1126,8 +1126,8 @@ if (tint_build_unittests) {
"resolver/resolver_test_helper.cc",
"resolver/resolver_test_helper.h",
"resolver/side_effects_test.cc",
"resolver/static_assert_test.cc",
"resolver/source_variable_test.cc",
"resolver/static_assert_test.cc",
"resolver/storage_class_layout_validation_test.cc",
"resolver/storage_class_validation_test.cc",
"resolver/struct_layout_test.cc",
@ -1349,11 +1349,11 @@ if (tint_build_unittests) {
"reader/wgsl/parser_impl_and_expression_test.cc",
"reader/wgsl/parser_impl_argument_expression_list_test.cc",
"reader/wgsl/parser_impl_assignment_stmt_test.cc",
"reader/wgsl/parser_impl_body_stmt_test.cc",
"reader/wgsl/parser_impl_break_stmt_test.cc",
"reader/wgsl/parser_impl_bug_cases_test.cc",
"reader/wgsl/parser_impl_call_stmt_test.cc",
"reader/wgsl/parser_impl_case_body_test.cc",
"reader/wgsl/parser_impl_compound_stmt_test.cc",
"reader/wgsl/parser_impl_const_literal_test.cc",
"reader/wgsl/parser_impl_continue_stmt_test.cc",
"reader/wgsl/parser_impl_continuing_stmt_test.cc",

2
src/tint/CMakeLists.txt
View File

@ -944,11 +944,11 @@ if(TINT_BUILD_TESTS)
reader/wgsl/parser_impl_and_expression_test.cc
reader/wgsl/parser_impl_argument_expression_list_test.cc
reader/wgsl/parser_impl_assignment_stmt_test.cc
reader/wgsl/parser_impl_body_stmt_test.cc
reader/wgsl/parser_impl_break_stmt_test.cc
reader/wgsl/parser_impl_bug_cases_test.cc
reader/wgsl/parser_impl_call_stmt_test.cc
reader/wgsl/parser_impl_case_body_test.cc
reader/wgsl/parser_impl_compound_stmt_test.cc
reader/wgsl/parser_impl_const_literal_test.cc
reader/wgsl/parser_impl_continue_stmt_test.cc
reader/wgsl/parser_impl_continuing_stmt_test.cc

176
src/tint/reader/wgsl/parser_impl.cc
View File

@ -482,7 +482,7 @@ Maybe<bool> ParserImpl::global_decl() {
return true;
}
auto assertion = static_assert_stmt();
auto assertion = static_assert_statement();
if (assertion.errored) {
return Failure::kErrored;
}
@ -1368,7 +1368,7 @@ Expect<ast::StructMember*> ParserImpl::expect_struct_member() {
// static_assert
// : STATIC_ASSERT expression
Maybe<const ast::StaticAssert*> ParserImpl::static_assert_stmt() {
Maybe<const ast::StaticAssert*> ParserImpl::static_assert_statement() {
Source start;
if (!match(Token::Type::kStaticAssert, &start)) {
return Failure::kNoMatch;
@ -1387,7 +1387,7 @@ Maybe<const ast::StaticAssert*> ParserImpl::static_assert_stmt() {
}
// function_decl
// : function_header body_stmt
// : function_header compound_statement
Maybe<const ast::Function*> ParserImpl::function_decl(AttributeList& attrs) {
auto header = function_header();
if (header.errored) {
@ -1398,7 +1398,7 @@ Maybe<const ast::Function*> ParserImpl::function_decl(AttributeList& attrs) {
// function body. The AST isn't used as we've already errored, but this
// catches any errors inside the body, and can help keep the parser in
// sync.
expect_body_stmt();
expect_compound_statement();
}
return Failure::kErrored;
}
@ -1408,7 +1408,7 @@ Maybe<const ast::Function*> ParserImpl::function_decl(AttributeList& attrs) {
bool errored = false;
auto body = expect_body_stmt();
auto body = expect_compound_statement();
if (body.errored) {
errored = true;
}
@ -1624,9 +1624,9 @@ Expect<ast::BuiltinValue> ParserImpl::expect_builtin() {
return {builtin, ident.source};
}
// body_stmt
// : BRACE_LEFT statements BRACE_RIGHT
Expect<ast::BlockStatement*> ParserImpl::expect_body_stmt() {
// compound_statement
// : BRACE_LEFT statement* BRACE_RIGHT
Expect<ast::BlockStatement*> ParserImpl::expect_compound_statement() {
return expect_brace_block("", [&]() -> Expect<ast::BlockStatement*> {
auto stmts = expect_statements();
if (stmts.errored) {
@ -1678,23 +1678,13 @@ Expect<ParserImpl::StatementList> ParserImpl::expect_statements() {
// statement
// : SEMICOLON
// | body_stmt?
// | if_stmt
// | switch_stmt
// | loop_stmt
// | for_stmt
// | while_stmt
// | non_block_statement
// : return_stmt SEMICOLON
// | func_call_stmt SEMICOLON
// | variable_stmt SEMICOLON
// | break_stmt SEMICOLON
// | continue_stmt SEMICOLON
// | DISCARD SEMICOLON
// | assignment_stmt SEMICOLON
// | increment_stmt SEMICOLON
// | decrement_stmt SEMICOLON
// | static_assert_stmt SEMICOLON
// | if_statement
// | switch_statement
// | loop_statement
// | for_statement
// | while_statement
// | compound_statement
// | non_block_statement // Note, we inject an extra rule in here for simpler parsing
Maybe<const ast::Statement*> ParserImpl::statement() {
while (match(Token::Type::kSemicolon)) {
// Skip empty statements
@ -1702,7 +1692,6 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
// Non-block statements that error can resynchronize on semicolon.
auto stmt = sync(Token::Type::kSemicolon, [&] { return non_block_statement(); });
if (stmt.errored) {
return Failure::kErrored;
}
@ -1710,7 +1699,7 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
return stmt;
}
auto stmt_if = if_stmt();
auto stmt_if = if_statement();
if (stmt_if.errored) {
return Failure::kErrored;
}
@ -1718,7 +1707,7 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
return stmt_if.value;
}
auto sw = switch_stmt();
auto sw = switch_statement();
if (sw.errored) {
return Failure::kErrored;
}
@ -1726,7 +1715,7 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
return sw.value;
}
auto loop = loop_stmt();
auto loop = loop_statement();
if (loop.errored) {
return Failure::kErrored;
}
@ -1734,7 +1723,7 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
return loop.value;
}
auto stmt_for = for_stmt();
auto stmt_for = for_statement();
if (stmt_for.errored) {
return Failure::kErrored;
}
@ -1742,7 +1731,7 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
return stmt_for.value;
}
auto stmt_while = while_stmt();
auto stmt_while = while_statement();
if (stmt_while.errored) {
return Failure::kErrored;
}
@ -1751,7 +1740,7 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
}
if (peek_is(Token::Type::kBraceLeft)) {
auto body = expect_body_stmt();
auto body = expect_compound_statement();
if (body.errored) {
return Failure::kErrored;
}
@ -1761,19 +1750,20 @@ Maybe<const ast::Statement*> ParserImpl::statement() {
return Failure::kNoMatch;
}
// statement (continued)
// : return_stmt SEMICOLON
// | func_call_stmt SEMICOLON
// | variable_stmt SEMICOLON
// | break_stmt SEMICOLON
// | continue_stmt SEMICOLON
// non_block_statement (continued)
// : return_statement SEMICOLON
// | func_call_statement SEMICOLON
// | variable_statement SEMICOLON
// | break_statement SEMICOLON
// | continue_statement SEMICOLON
// | DISCARD SEMICOLON
// | assignment_stmt SEMICOLON
// | increment_stmt SEMICOLON
// | decrement_stmt SEMICOLON
// | assignment_statement SEMICOLON
// | increment_statement SEMICOLON
// | decrement_statement SEMICOLON
// | static_assert_statement SEMICOLON
Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
auto stmt = [&]() -> Maybe<const ast::Statement*> {
auto ret_stmt = return_stmt();
auto ret_stmt = return_statement();
if (ret_stmt.errored) {
return Failure::kErrored;
}
@ -1781,7 +1771,7 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return ret_stmt.value;
}
auto func = func_call_stmt();
auto func = func_call_statement();
if (func.errored) {
return Failure::kErrored;
}
@ -1789,7 +1779,7 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return func.value;
}
auto var = variable_stmt();
auto var = variable_statement();
if (var.errored) {
return Failure::kErrored;
}
@ -1797,7 +1787,7 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return var.value;
}
auto b = break_stmt();
auto b = break_statement();
if (b.errored) {
return Failure::kErrored;
}
@ -1805,7 +1795,7 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return b.value;
}
auto cont = continue_stmt();
auto cont = continue_statement();
if (cont.errored) {
return Failure::kErrored;
}
@ -1813,7 +1803,13 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return cont.value;
}
auto assign = assignment_stmt();
Source source;
if (match(Token::Type::kDiscard, &source)) {
return create<ast::DiscardStatement>(source);
}
// Note, this covers assignment, increment and decrement
auto assign = assignment_statement();
if (assign.errored) {
return Failure::kErrored;
}
@ -1821,7 +1817,7 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return assign.value;
}
auto stmt_static_assert = static_assert_stmt();
auto stmt_static_assert = static_assert_statement();
if (stmt_static_assert.errored) {
return Failure::kErrored;
}
@ -1829,24 +1825,18 @@ Maybe<const ast::Statement*> ParserImpl::non_block_statement() {
return stmt_static_assert.value;
}
Source source;
if (match(Token::Type::kDiscard, &source)) {
return create<ast::DiscardStatement>(source);
}
return Failure::kNoMatch;
}();
if (stmt.matched && !expect(stmt->Name(), Token::Type::kSemicolon)) {
return Failure::kErrored;
}
return stmt;
}
// return_stmt
// return_statement
// : RETURN expression?
Maybe<const ast::ReturnStatement*> ParserImpl::return_stmt() {
Maybe<const ast::ReturnStatement*> ParserImpl::return_statement() {
Source source;
if (!match(Token::Type::kReturn, &source)) {
return Failure::kNoMatch;
@ -1865,11 +1855,11 @@ Maybe<const ast::ReturnStatement*> ParserImpl::return_stmt() {
return create<ast::ReturnStatement>(source, expr.value);
}
// variable_stmt
// variable_statement
// : variable_decl
// | variable_decl EQUAL expression
// | CONST variable_ident_decl EQUAL expression
Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_stmt() {
Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_statement() {
if (match(Token::Type::kConst)) {
auto decl = expect_variable_ident_decl("'const' declaration",
/*allow_inferred = */ true);
@ -1958,12 +1948,12 @@ Maybe<const ast::VariableDeclStatement*> ParserImpl::variable_stmt() {
return create<ast::VariableDeclStatement>(var->source, var);
}
// if_stmt
// if_statement
// : IF expression compound_stmt ( ELSE else_stmt ) ?
// else_stmt
// : body_stmt
// | if_stmt
Maybe<const ast::IfStatement*> ParserImpl::if_stmt() {
// : compound_statement
// | if_statement
Maybe<const ast::IfStatement*> ParserImpl::if_statement() {
// Parse if-else chains iteratively instead of recursively, to avoid
// stack-overflow for long chains of if-else statements.
@ -1988,7 +1978,7 @@ Maybe<const ast::IfStatement*> ParserImpl::if_stmt() {
return add_error(peek(), "unable to parse condition expression");
}
auto body = expect_body_stmt();
auto body = expect_compound_statement();
if (body.errored) {
return Failure::kErrored;
}
@ -2024,7 +2014,7 @@ Maybe<const ast::IfStatement*> ParserImpl::if_stmt() {
}
// If it wasn't an "else if", it must just be an "else".
auto else_body = expect_body_stmt();
auto else_body = expect_compound_statement();
if (else_body.errored) {
return Failure::kErrored;
}
@ -2040,9 +2030,9 @@ Maybe<const ast::IfStatement*> ParserImpl::if_stmt() {
return last_stmt->As<ast::IfStatement>();
}
// switch_stmt
// switch_statement
// : SWITCH expression BRACKET_LEFT switch_body+ BRACKET_RIGHT
Maybe<const ast::SwitchStatement*> ParserImpl::switch_stmt() {
Maybe<const ast::SwitchStatement*> ParserImpl::switch_statement() {
Source source;
if (!match(Token::Type::kSwitch, &source)) {
return Failure::kNoMatch;
@ -2179,9 +2169,9 @@ Maybe<const ast::BlockStatement*> ParserImpl::case_body() {
return create<ast::BlockStatement>(Source{}, stmts);
}
// loop_stmt
// loop_statement
// : LOOP BRACKET_LEFT statements continuing_stmt? BRACKET_RIGHT
Maybe<const ast::LoopStatement*> ParserImpl::loop_stmt() {
Maybe<const ast::LoopStatement*> ParserImpl::loop_statement() {
Source source;
if (!match(Token::Type::kLoop, &source)) {
return Failure::kNoMatch;
@ -2210,10 +2200,10 @@ ForHeader::ForHeader(const ast::Statement* init,
ForHeader::~ForHeader() = default;
// (variable_stmt | increment_stmt | decrement_stmt | assignment_stmt |
// func_call_stmt)?
// (variable_statement | increment_statement | decrement_statement | assignment_statement |
// func_call_statement)?
Maybe<const ast::Statement*> ParserImpl::for_header_initializer() {
auto call = func_call_stmt();
auto call = func_call_statement();
if (call.errored) {
return Failure::kErrored;
}
@ -2221,7 +2211,7 @@ Maybe<const ast::Statement*> ParserImpl::for_header_initializer() {
return call.value;
}
auto var = variable_stmt();
auto var = variable_statement();
if (var.errored) {
return Failure::kErrored;
}
@ -2229,7 +2219,7 @@ Maybe<const ast::Statement*> ParserImpl::for_header_initializer() {
return var.value;
}
auto assign = assignment_stmt();
auto assign = assignment_statement();
if (assign.errored) {
return Failure::kErrored;
}
@ -2240,9 +2230,9 @@ Maybe<const ast::Statement*> ParserImpl::for_header_initializer() {
return Failure::kNoMatch;
}
// (increment_stmt | decrement_stmt | assignment_stmt | func_call_stmt)?
// (increment_statement | decrement_statement | assignment_statement | func_call_statement)?
Maybe<const ast::Statement*> ParserImpl::for_header_continuing() {
auto call_stmt = func_call_stmt();
auto call_stmt = func_call_statement();
if (call_stmt.errored) {
return Failure::kErrored;
}
@ -2250,7 +2240,7 @@ Maybe<const ast::Statement*> ParserImpl::for_header_continuing() {
return call_stmt.value;
}
auto assign = assignment_stmt();
auto assign = assignment_statement();
if (assign.errored) {
return Failure::kErrored;
}
@ -2262,10 +2252,10 @@ Maybe<const ast::Statement*> ParserImpl::for_header_continuing() {
}
// for_header
// : (variable_stmt | assignment_stmt | func_call_stmt)?
// : (variable_statement | assignment_statement | func_call_statement)?
// SEMICOLON
// expression? SEMICOLON
// (assignment_stmt | func_call_stmt)?
// (assignment_statement | func_call_statement)?
Expect<std::unique_ptr<ForHeader>> ParserImpl::expect_for_header() {
auto initializer = for_header_initializer();
if (initializer.errored) {
@ -2295,7 +2285,7 @@ Expect<std::unique_ptr<ForHeader>> ParserImpl::expect_for_header() {
// for_statement
// : FOR PAREN_LEFT for_header PAREN_RIGHT BRACE_LEFT statements BRACE_RIGHT
Maybe<const ast::ForLoopStatement*> ParserImpl::for_stmt() {
Maybe<const ast::ForLoopStatement*> ParserImpl::for_statement() {
Source source;
if (!match(Token::Type::kFor, &source)) {
return Failure::kNoMatch;
@ -2318,7 +2308,7 @@ Maybe<const ast::ForLoopStatement*> ParserImpl::for_stmt() {
// while_statement
// : WHILE expression compound_statement
Maybe<const ast::WhileStatement*> ParserImpl::while_stmt() {
Maybe<const ast::WhileStatement*> ParserImpl::while_statement() {
Source source;
if (!match(Token::Type::kWhile, &source)) {
return Failure::kNoMatch;
@ -2332,7 +2322,7 @@ Maybe<const ast::WhileStatement*> ParserImpl::while_stmt() {
return add_error(peek(), "unable to parse while condition expression");
}
auto body = expect_body_stmt();
auto body = expect_compound_statement();
if (body.errored) {
return Failure::kErrored;
}
@ -2340,9 +2330,9 @@ Maybe<const ast::WhileStatement*> ParserImpl::while_stmt() {
return create<ast::WhileStatement>(source, condition.value, body.value);
}
// func_call_stmt
// func_call_statement
// : IDENT argument_expression_list
Maybe<const ast::CallStatement*> ParserImpl::func_call_stmt() {
Maybe<const ast::CallStatement*> ParserImpl::func_call_statement() {
auto& t = peek();
auto& t2 = peek(1);
if (!t.IsIdentifier() || !t2.Is(Token::Type::kParenLeft)) {
@ -2364,9 +2354,9 @@ Maybe<const ast::CallStatement*> ParserImpl::func_call_stmt() {
std::move(params.value)));
}
// break_stmt
// break_statement
// : BREAK
Maybe<const ast::BreakStatement*> ParserImpl::break_stmt() {
Maybe<const ast::BreakStatement*> ParserImpl::break_statement() {
Source source;
if (!match(Token::Type::kBreak, &source)) {
return Failure::kNoMatch;
@ -2375,9 +2365,9 @@ Maybe<const ast::BreakStatement*> ParserImpl::break_stmt() {
return create<ast::BreakStatement>(source);
}
// continue_stmt
// continue_statement
// : CONTINUE
Maybe<const ast::ContinueStatement*> ParserImpl::continue_stmt() {
Maybe<const ast::ContinueStatement*> ParserImpl::continue_statement() {
Source source;
if (!match(Token::Type::kContinue, &source)) {
return Failure::kNoMatch;
@ -2387,13 +2377,13 @@ Maybe<const ast::ContinueStatement*> ParserImpl::continue_stmt() {
}
// continuing_stmt
// : CONTINUING body_stmt
// : CONTINUING compound_statement
Maybe<const ast::BlockStatement*> ParserImpl::continuing_stmt() {
if (!match(Token::Type::kContinuing)) {
return create<ast::BlockStatement>(Source{}, utils::Empty);
}
return expect_body_stmt();
return expect_compound_statement();
}
// primary_expression
@ -3088,16 +3078,16 @@ Maybe<ast::BinaryOp> ParserImpl::compound_assignment_operator() {
return Failure::kNoMatch;
}
// assignment_stmt
// assignment_statement
// | lhs_expression ( equal | compound_assignment_operator ) expression
// | underscore equal expression
//
// increment_stmt
// increment_statement
// | lhs_expression PLUS_PLUS
//
// decrement_stmt
// decrement_statement
// | lhs_expression MINUS_MINUS
Maybe<const ast::Statement*> ParserImpl::assignment_stmt() {
Maybe<const ast::Statement*> ParserImpl::assignment_statement() {
auto& t = peek();
// tint:295 - Test for `ident COLON` - this is invalid grammar, and without

50
src/tint/reader/wgsl/parser_impl.h
View File

@ -474,7 +474,7 @@ class ParserImpl {
Expect<ast::TexelFormat> expect_texel_format(std::string_view use);
/// Parses a `static_assert_statement` grammar element
/// @returns returns the static assert, if it matched.
Maybe<const ast::StaticAssert*> static_assert_stmt();
Maybe<const ast::StaticAssert*> static_assert_statement();
/// Parses a `function_header` grammar element
/// @returns the parsed function header
Maybe<FunctionHeader> function_header();
@ -505,9 +505,9 @@ class ParserImpl {
/// valid builtin name.
/// @returns the parsed builtin.
Expect<ast::BuiltinValue> expect_builtin();
/// Parses a `body_stmt` grammar element, erroring on parse failure.
/// Parses a `compound_statement` grammar element, erroring on parse failure.
/// @returns the parsed statements
Expect<ast::BlockStatement*> expect_body_stmt();
Expect<ast::BlockStatement*> expect_compound_statement();
/// Parses a `paren_expression` grammar element, erroring on parse failure.
/// @returns the parsed element or nullptr
Expect<const ast::Expression*> expect_paren_expression();
@ -517,24 +517,24 @@ class ParserImpl {
/// Parses a `statement` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::Statement*> statement();
/// Parses a `break_stmt` grammar element
/// Parses a `break_statement` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::BreakStatement*> break_stmt();
/// Parses a `return_stmt` grammar element
Maybe<const ast::BreakStatement*> break_statement();
/// Parses a `return_statement` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::ReturnStatement*> return_stmt();
/// Parses a `continue_stmt` grammar element
Maybe<const ast::ReturnStatement*> return_statement();
/// Parses a `continue_statement` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::ContinueStatement*> continue_stmt();
/// Parses a `variable_stmt` grammar element
Maybe<const ast::ContinueStatement*> continue_statement();
/// Parses a `variable_statement` grammar element
/// @returns the parsed variable or nullptr
Maybe<const ast::VariableDeclStatement*> variable_stmt();
/// Parses a `if_stmt` grammar element
Maybe<const ast::VariableDeclStatement*> variable_statement();
/// Parses a `if_statement` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::IfStatement*> if_stmt();
/// Parses a `switch_stmt` grammar element
Maybe<const ast::IfStatement*> if_statement();
/// Parses a `switch_statement` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::SwitchStatement*> switch_stmt();
Maybe<const ast::SwitchStatement*> switch_statement();
/// Parses a `switch_body` grammar element
/// @returns the parsed statement or nullptr
Maybe<const ast::CaseStatement*> switch_body();
@ -544,21 +544,21 @@ class ParserImpl {
/// Parses a `case_body` grammar element
/// @returns the parsed statements
Maybe<const ast::BlockStatement*> case_body();
/// Parses a `func_call_stmt` grammar element
/// Parses a `func_call_statement` grammar element
/// @returns the parsed function call or nullptr
Maybe<const ast::CallStatement*> func_call_stmt();
/// Parses a `loop_stmt` grammar element
Maybe<const ast::CallStatement*> func_call_statement();
/// Parses a `loop_statement` grammar element
/// @returns the parsed loop or nullptr
Maybe<const ast::LoopStatement*> loop_stmt();
Maybe<const ast::LoopStatement*> loop_statement();
/// Parses a `for_header` grammar element, erroring on parse failure.
/// @returns the parsed for header or nullptr
Expect<std::unique_ptr<ForHeader>> expect_for_header();
/// Parses a `for_stmt` grammar element
/// Parses a `for_statement` grammar element
/// @returns the parsed for loop or nullptr
Maybe<const ast::ForLoopStatement*> for_stmt();
/// Parses a `while_stmt` grammar element
Maybe<const ast::ForLoopStatement*> for_statement();
/// Parses a `while_statement` grammar element
/// @returns the parsed while loop or nullptr
Maybe<const ast::WhileStatement*> while_stmt();
Maybe<const ast::WhileStatement*> while_statement();
/// Parses a `continuing_stmt` grammar element
/// @returns the parsed statements
Maybe<const ast::BlockStatement*> continuing_stmt();
@ -669,9 +669,9 @@ class ParserImpl {
/// Parses a `compound_assignment_operator` grammar element
/// @returns the parsed compound assignment operator
Maybe<ast::BinaryOp> compound_assignment_operator();
/// Parses a `assignment_stmt` grammar element
/// Parses a `assignment_statement` grammar element
/// @returns the parsed assignment or nullptr
Maybe<const ast::Statement*> assignment_stmt();
Maybe<const ast::Statement*> assignment_statement();
/// Parses one or more attribute lists.
/// @return the parsed attribute list, or an empty list on error.
Maybe<AttributeList> attribute_list();

18
src/tint/reader/wgsl/parser_impl_assignment_stmt_test.cc
View File

@ -19,7 +19,7 @@ namespace {
TEST_F(ParserImplTest, AssignmentStmt_Parses_ToVariable) {
auto p = parser("a = 123");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -42,7 +42,7 @@ TEST_F(ParserImplTest, AssignmentStmt_Parses_ToVariable) {
TEST_F(ParserImplTest, AssignmentStmt_Parses_ToMember) {
auto p = parser("a.b.c[2].d = 123");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -92,7 +92,7 @@ TEST_F(ParserImplTest, AssignmentStmt_Parses_ToMember) {
TEST_F(ParserImplTest, AssignmentStmt_Parses_ToPhony) {
auto p = parser("_ = 123i");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -119,7 +119,7 @@ using CompoundOpTest = ParserImplTestWithParam<CompoundData>;
TEST_P(CompoundOpTest, CompoundOp) {
auto params = GetParam();
auto p = parser("a " + params.str + " 123u");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -155,7 +155,7 @@ INSTANTIATE_TEST_SUITE_P(ParserImplTest,
TEST_F(ParserImplTest, AssignmentStmt_MissingEqual) {
auto p = parser("a.b.c[2].d 123");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_TRUE(p->has_error());
@ -165,7 +165,7 @@ TEST_F(ParserImplTest, AssignmentStmt_MissingEqual) {
TEST_F(ParserImplTest, AssignmentStmt_Compound_MissingEqual) {
auto p = parser("a + 123");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_TRUE(p->has_error());
@ -175,7 +175,7 @@ TEST_F(ParserImplTest, AssignmentStmt_Compound_MissingEqual) {
TEST_F(ParserImplTest, AssignmentStmt_InvalidLHS) {
auto p = parser("if (true) {} = 123");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_FALSE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -184,7 +184,7 @@ TEST_F(ParserImplTest, AssignmentStmt_InvalidLHS) {
TEST_F(ParserImplTest, AssignmentStmt_InvalidRHS) {
auto p = parser("a.b.c[2].d = if (true) {}");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -194,7 +194,7 @@ TEST_F(ParserImplTest, AssignmentStmt_InvalidRHS) {
TEST_F(ParserImplTest, AssignmentStmt_InvalidCompoundOp) {
auto p = parser("a &&= true");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);

2
src/tint/reader/wgsl/parser_impl_break_stmt_test.cc
View File

@ -20,7 +20,7 @@ namespace {
TEST_F(ParserImplTest, BreakStmt) {
auto p = parser("break");
auto e = p->break_stmt();
auto e = p->break_statement();
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);

16
src/tint/reader/wgsl/parser_impl_body_stmt_test.cc → src/tint/reader/wgsl/parser_impl_compound_stmt_test.cc
View File

@ -18,12 +18,12 @@
namespace tint::reader::wgsl {
namespace {
TEST_F(ParserImplTest, BodyStmt) {
TEST_F(ParserImplTest, CompoundStmt) {
auto p = parser(R"({
discard;
return 1 + b / 2;
})");
auto e = p->expect_body_stmt();
auto e = p->expect_compound_statement();
ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(e.errored);
ASSERT_EQ(e->statements.Length(), 2u);
@ -31,25 +31,25 @@ TEST_F(ParserImplTest, BodyStmt) {
EXPECT_TRUE(e->statements[1]->Is<ast::ReturnStatement>());
}
TEST_F(ParserImplTest, BodyStmt_Empty) {
TEST_F(ParserImplTest, CompoundStmt_Empty) {
auto p = parser("{}");
auto e = p->expect_body_stmt();
auto e = p->expect_compound_statement();
ASSERT_FALSE(p->has_error()) << p->error();
ASSERT_FALSE(e.errored);
EXPECT_EQ(e->statements.Length(), 0u);
}
TEST_F(ParserImplTest, BodyStmt_InvalidStmt) {
TEST_F(ParserImplTest, CompoundStmt_InvalidStmt) {
auto p = parser("{fn main() {}}");
auto e = p->expect_body_stmt();
auto e = p->expect_compound_statement();
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(e.errored);
EXPECT_EQ(p->error(), "1:2: expected '}'");
}
TEST_F(ParserImplTest, BodyStmt_MissingRightParen) {
TEST_F(ParserImplTest, CompoundStmt_MissingRightParen) {
auto p = parser("{return;");
auto e = p->expect_body_stmt();
auto e = p->expect_compound_statement();
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(e.errored);
EXPECT_EQ(p->error(), "1:9: expected '}'");

2
src/tint/reader/wgsl/parser_impl_continue_stmt_test.cc
View File

@ -20,7 +20,7 @@ namespace {
TEST_F(ParserImplTest, ContinueStmt) {
auto p = parser("continue");
auto e = p->continue_stmt();
auto e = p->continue_statement();
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
ASSERT_NE(e.value, nullptr);

26
src/tint/reader/wgsl/parser_impl_for_stmt_test.cc
View File

@ -24,7 +24,7 @@ using ForStmtTest = ParserImplTest;
// Test an empty for loop.
TEST_F(ForStmtTest, Empty) {
auto p = parser("for (;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -37,7 +37,7 @@ TEST_F(ForStmtTest, Empty) {
// Test a for loop with non-empty body.
TEST_F(ForStmtTest, Body) {
auto p = parser("for (;;) { discard; }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -51,7 +51,7 @@ TEST_F(ForStmtTest, Body) {
// Test a for loop declaring a variable in the initializer statement.
TEST_F(ForStmtTest, InitializerStatementDecl) {
auto p = parser("for (var i: i32 ;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -68,7 +68,7 @@ TEST_F(ForStmtTest, InitializerStatementDecl) {
// statement.
TEST_F(ForStmtTest, InitializerStatementDeclEqual) {
auto p = parser("for (var i: i32 = 0 ;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -84,7 +84,7 @@ TEST_F(ForStmtTest, InitializerStatementDeclEqual) {
// Test a for loop declaring a const variable in the initializer statement.
TEST_F(ForStmtTest, InitializerStatementConstDecl) {
auto p = parser("for (let i: i32 = 0 ;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -100,7 +100,7 @@ TEST_F(ForStmtTest, InitializerStatementConstDecl) {
// Test a for loop assigning a variable in the initializer statement.
TEST_F(ForStmtTest, InitializerStatementAssignment) {
auto p = parser("for (i = 0 ;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -113,7 +113,7 @@ TEST_F(ForStmtTest, InitializerStatementAssignment) {
// Test a for loop incrementing a variable in the initializer statement.
TEST_F(ForStmtTest, InitializerStatementIncrement) {
auto p = parser("for (i++;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -126,7 +126,7 @@ TEST_F(ForStmtTest, InitializerStatementIncrement) {
// Test a for loop calling a function in the initializer statement.
TEST_F(ForStmtTest, InitializerStatementFuncCall) {
auto p = parser("for (a(b,c) ;;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -139,7 +139,7 @@ TEST_F(ForStmtTest, InitializerStatementFuncCall) {
// Test a for loop with a break condition
TEST_F(ForStmtTest, BreakCondition) {
auto p = parser("for (; 0 == 1;) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -152,7 +152,7 @@ TEST_F(ForStmtTest, BreakCondition) {
// Test a for loop assigning a variable in the continuing statement.
TEST_F(ForStmtTest, ContinuingAssignment) {
auto p = parser("for (;; x = 2) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -165,7 +165,7 @@ TEST_F(ForStmtTest, ContinuingAssignment) {
// Test a for loop with an increment statement as the continuing statement.
TEST_F(ForStmtTest, ContinuingIncrement) {
auto p = parser("for (;; x++) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -178,7 +178,7 @@ TEST_F(ForStmtTest, ContinuingIncrement) {
// Test a for loop calling a function in the continuing statement.
TEST_F(ForStmtTest, ContinuingFuncCall) {
auto p = parser("for (;; a(b,c)) { }");
auto fl = p->for_stmt();
auto fl = p->for_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(fl.errored);
ASSERT_TRUE(fl.matched);
@ -192,7 +192,7 @@ class ForStmtErrorTest : public ParserImplTest {
public:
void TestForWithError(std::string for_str, std::string error_str) {
auto p_for = parser(for_str);
auto e_for = p_for->for_stmt();
auto e_for = p_for->for_statement();
EXPECT_FALSE(e_for.matched);
EXPECT_TRUE(e_for.errored);

18
src/tint/reader/wgsl/parser_impl_if_stmt_test.cc
View File

@ -19,7 +19,7 @@ namespace {
TEST_F(ParserImplTest, IfStmt) {
auto p = parser("if a == 4 { a = b; c = d; }");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -34,7 +34,7 @@ TEST_F(ParserImplTest, IfStmt) {
TEST_F(ParserImplTest, IfStmt_WithElse) {
auto p = parser("if a == 4 { a = b; c = d; } else if(c) { d = 2; } else {}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -57,7 +57,7 @@ TEST_F(ParserImplTest, IfStmt_WithElse) {
TEST_F(ParserImplTest, IfStmt_WithElse_WithParens) {
auto p = parser("if(a==4) { a = b; c = d; } else if(c) { d = 2; } else {}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -80,7 +80,7 @@ TEST_F(ParserImplTest, IfStmt_WithElse_WithParens) {
TEST_F(ParserImplTest, IfStmt_InvalidCondition) {
auto p = parser("if a = 3 {}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -90,7 +90,7 @@ TEST_F(ParserImplTest, IfStmt_InvalidCondition) {
TEST_F(ParserImplTest, IfStmt_MissingCondition) {
auto p = parser("if {}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -100,7 +100,7 @@ TEST_F(ParserImplTest, IfStmt_MissingCondition) {
TEST_F(ParserImplTest, IfStmt_InvalidBody) {
auto p = parser("if a { fn main() {}}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -110,7 +110,7 @@ TEST_F(ParserImplTest, IfStmt_InvalidBody) {
TEST_F(ParserImplTest, IfStmt_MissingBody) {
auto p = parser("if a");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -120,7 +120,7 @@ TEST_F(ParserImplTest, IfStmt_MissingBody) {
TEST_F(ParserImplTest, IfStmt_InvalidElseif) {
auto p = parser("if a {} else if a { fn main() -> a{}}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -130,7 +130,7 @@ TEST_F(ParserImplTest, IfStmt_InvalidElseif) {
TEST_F(ParserImplTest, IfStmt_InvalidElse) {
auto p = parser("if a {} else { fn main() -> a{}}");
auto e = p->if_stmt();
auto e = p->if_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);

10
src/tint/reader/wgsl/parser_impl_increment_decrement_stmt_test.cc
View File

@ -19,7 +19,7 @@ namespace {
TEST_F(ParserImplTest, IncrementDecrementStmt_Increment) {
auto p = parser("a++");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -38,7 +38,7 @@ TEST_F(ParserImplTest, IncrementDecrementStmt_Increment) {
TEST_F(ParserImplTest, IncrementDecrementStmt_Decrement) {
auto p = parser("a--");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -57,7 +57,7 @@ TEST_F(ParserImplTest, IncrementDecrementStmt_Decrement) {
TEST_F(ParserImplTest, IncrementDecrementStmt_Parenthesized) {
auto p = parser("(a)++");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -76,7 +76,7 @@ TEST_F(ParserImplTest, IncrementDecrementStmt_Parenthesized) {
TEST_F(ParserImplTest, IncrementDecrementStmt_ToMember) {
auto p = parser("a.b.c[2].d++");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -121,7 +121,7 @@ TEST_F(ParserImplTest, IncrementDecrementStmt_ToMember) {
TEST_F(ParserImplTest, IncrementDecrementStmt_InvalidLHS) {
auto p = parser("{}++");
auto e = p->assignment_stmt();
auto e = p->assignment_statement();
EXPECT_FALSE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();

16
src/tint/reader/wgsl/parser_impl_loop_stmt_test.cc
View File

@ -20,7 +20,7 @@ namespace {
TEST_F(ParserImplTest, LoopStmt_BodyNoContinuing) {
auto p = parser("loop { discard; }");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -34,7 +34,7 @@ TEST_F(ParserImplTest, LoopStmt_BodyNoContinuing) {
TEST_F(ParserImplTest, LoopStmt_BodyWithContinuing) {
auto p = parser("loop { discard; continuing { discard; }}");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -49,7 +49,7 @@ TEST_F(ParserImplTest, LoopStmt_BodyWithContinuing) {
TEST_F(ParserImplTest, LoopStmt_NoBodyNoContinuing) {
auto p = parser("loop { }");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -60,7 +60,7 @@ TEST_F(ParserImplTest, LoopStmt_NoBodyNoContinuing) {
TEST_F(ParserImplTest, LoopStmt_NoBodyWithContinuing) {
auto p = parser("loop { continuing { discard; }}");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -72,7 +72,7 @@ TEST_F(ParserImplTest, LoopStmt_NoBodyWithContinuing) {
TEST_F(ParserImplTest, LoopStmt_MissingBracketLeft) {
auto p = parser("loop discard; }");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -82,7 +82,7 @@ TEST_F(ParserImplTest, LoopStmt_MissingBracketLeft) {
TEST_F(ParserImplTest, LoopStmt_MissingBracketRight) {
auto p = parser("loop { discard; ");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -92,7 +92,7 @@ TEST_F(ParserImplTest, LoopStmt_MissingBracketRight) {
TEST_F(ParserImplTest, LoopStmt_InvalidStatements) {
auto p = parser("loop { discard }");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -102,7 +102,7 @@ TEST_F(ParserImplTest, LoopStmt_InvalidStatements) {
TEST_F(ParserImplTest, LoopStmt_InvalidContinuing) {
auto p = parser("loop { continuing { discard }}");
auto e = p->loop_stmt();
auto e = p->loop_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);

18
src/tint/reader/wgsl/parser_impl_switch_stmt_test.cc
View File

@ -22,7 +22,7 @@ TEST_F(ParserImplTest, SwitchStmt_WithoutDefault) {
case 1: {}
case 2: {}
})");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -35,7 +35,7 @@ TEST_F(ParserImplTest, SwitchStmt_WithoutDefault) {
TEST_F(ParserImplTest, SwitchStmt_Empty) {
auto p = parser("switch a { }");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -50,7 +50,7 @@ TEST_F(ParserImplTest, SwitchStmt_DefaultInMiddle) {
default: {}
case 2: {}
})");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -65,7 +65,7 @@ TEST_F(ParserImplTest, SwitchStmt_DefaultInMiddle) {
TEST_F(ParserImplTest, SwitchStmt_WithParens) {
auto p = parser("switch(a+b) { }");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -76,7 +76,7 @@ TEST_F(ParserImplTest, SwitchStmt_WithParens) {
TEST_F(ParserImplTest, SwitchStmt_InvalidExpression) {
auto p = parser("switch a=b {}");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -86,7 +86,7 @@ TEST_F(ParserImplTest, SwitchStmt_InvalidExpression) {
TEST_F(ParserImplTest, SwitchStmt_MissingExpression) {
auto p = parser("switch {}");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -96,7 +96,7 @@ TEST_F(ParserImplTest, SwitchStmt_MissingExpression) {
TEST_F(ParserImplTest, SwitchStmt_MissingBracketLeft) {
auto p = parser("switch a }");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -106,7 +106,7 @@ TEST_F(ParserImplTest, SwitchStmt_MissingBracketLeft) {
TEST_F(ParserImplTest, SwitchStmt_MissingBracketRight) {
auto p = parser("switch a {");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -118,7 +118,7 @@ TEST_F(ParserImplTest, SwitchStmt_InvalidBody) {
auto p = parser(R"(switch a {
case: {}
})");
auto e = p->switch_stmt();
auto e = p->switch_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);

22
src/tint/reader/wgsl/parser_impl_variable_stmt_test.cc
View File

@ -19,7 +19,7 @@ namespace {
TEST_F(ParserImplTest, VariableStmt_VariableDecl) {
auto p = parser("var a : i32;");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -38,7 +38,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl) {
TEST_F(ParserImplTest, VariableStmt_VariableDecl_WithInit) {
auto p = parser("var a : i32 = 1;");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -58,7 +58,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_WithInit) {
TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
auto p = parser("var a : i32 = if(a) {}");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -68,7 +68,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit) {
auto p = parser("var a : array<i32> = array<i32>();");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -86,7 +86,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit) {
TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit_NoSpace) {
auto p = parser("var a : array<i32>=array<i32>();");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -104,7 +104,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_ArrayInit_NoSpace) {
TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit) {
auto p = parser("var a : vec2<i32> = vec2<i32>();");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -122,7 +122,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit) {
TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit_NoSpace) {
auto p = parser("var a : vec2<i32>=vec2<i32>();");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -140,7 +140,7 @@ TEST_F(ParserImplTest, VariableStmt_VariableDecl_VecInit_NoSpace) {
TEST_F(ParserImplTest, VariableStmt_Let) {
auto p = parser("let a : i32 = 1");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_TRUE(e.matched);
EXPECT_FALSE(e.errored);
EXPECT_FALSE(p->has_error()) << p->error();
@ -155,7 +155,7 @@ TEST_F(ParserImplTest, VariableStmt_Let) {
TEST_F(ParserImplTest, VariableStmt_Let_MissingEqual) {
auto p = parser("let a : i32 1");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -165,7 +165,7 @@ TEST_F(ParserImplTest, VariableStmt_Let_MissingEqual) {
TEST_F(ParserImplTest, VariableStmt_Let_MissingConstructor) {
auto p = parser("let a : i32 =");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
@ -175,7 +175,7 @@ TEST_F(ParserImplTest, VariableStmt_Let_MissingConstructor) {
TEST_F(ParserImplTest, VariableStmt_Let_InvalidConstructor) {
auto p = parser("let a : i32 = if (a) {}");
auto e = p->variable_stmt();
auto e = p->variable_statement();
EXPECT_FALSE(e.matched);
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);

10
src/tint/reader/wgsl/parser_impl_while_stmt_test.cc
View File

@ -24,7 +24,7 @@ using WhileStmtTest = ParserImplTest;
// Test an empty while loop.
TEST_F(WhileStmtTest, Empty) {
auto p = parser("while (true) { }");
auto wl = p->while_stmt();
auto wl = p->while_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(wl.errored);
ASSERT_TRUE(wl.matched);
@ -35,7 +35,7 @@ TEST_F(WhileStmtTest, Empty) {
// Test a while loop with non-empty body.
TEST_F(WhileStmtTest, Body) {
auto p = parser("while (true) { discard; }");
auto wl = p->while_stmt();
auto wl = p->while_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(wl.errored);
ASSERT_TRUE(wl.matched);
@ -47,7 +47,7 @@ TEST_F(WhileStmtTest, Body) {
// Test a while loop with complex condition.
TEST_F(WhileStmtTest, ComplexCondition) {
auto p = parser("while ((a + 1 - 2) == 3) { }");
auto wl = p->while_stmt();
auto wl = p->while_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(wl.errored);
ASSERT_TRUE(wl.matched);
@ -58,7 +58,7 @@ TEST_F(WhileStmtTest, ComplexCondition) {
// Test a while loop with no brackets.
TEST_F(WhileStmtTest, NoBrackets) {
auto p = parser("while (a + 1 - 2) == 3 { }");
auto wl = p->while_stmt();
auto wl = p->while_statement();
EXPECT_FALSE(p->has_error()) << p->error();
EXPECT_FALSE(wl.errored);
ASSERT_TRUE(wl.matched);
@ -70,7 +70,7 @@ class WhileStmtErrorTest : public ParserImplTest {
public:
void TestForWithError(std::string for_str, std::string error_str) {
auto p_for = parser(for_str);
auto e_for = p_for->while_stmt();
auto e_for = p_for->while_statement();
EXPECT_FALSE(e_for.matched);
EXPECT_TRUE(e_for.errored);