[wgsl-reader] Adding for loops

Implementing ParserImpl::for_stmt(). Also adding
for_stmt and body_stmt to ParserImpl::statement().

Bug: tint:138
Change-Id: Idc3f901648ca115f4d94b3614a940263ef841282
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/27261
Commit-Queue: Tomek Ponitka <tommek@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>

BUILD.gn

@@ -884,6 +884,7 @@ source_set("tint_unittests_wgsl_reader_src") {
     "src/reader/wgsl/parser_impl_entry_point_decl_test.cc",
     "src/reader/wgsl/parser_impl_equality_expression_test.cc",
     "src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc",
+    "src/reader/wgsl/parser_impl_for_stmt_test.cc",
     "src/reader/wgsl/parser_impl_function_decl_test.cc",
     "src/reader/wgsl/parser_impl_function_header_test.cc",
     "src/reader/wgsl/parser_impl_function_type_decl_test.cc",

src/CMakeLists.txt

@@ -417,6 +417,7 @@ if(${TINT_BUILD_WGSL_READER})
     reader/wgsl/parser_impl_entry_point_decl_test.cc
     reader/wgsl/parser_impl_equality_expression_test.cc
     reader/wgsl/parser_impl_exclusive_or_expression_test.cc
+    reader/wgsl/parser_impl_for_stmt_test.cc
     reader/wgsl/parser_impl_function_decl_test.cc
     reader/wgsl/parser_impl_function_header_test.cc
     reader/wgsl/parser_impl_function_type_decl_test.cc

src/reader/wgsl/lexer.cc

@@ -513,6 +513,8 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
     return {Token::Type::kFalse, source, "false"};
   if (str == "fn")
     return {Token::Type::kFn, source, "fn"};
+  if (str == "for")
+    return {Token::Type::kFor, source, "for"};
   if (str == "fragment")
     return {Token::Type::kFragment, source, "fragment"};
   if (str == "function")
@@ -610,8 +612,6 @@ Token Lexer::check_reserved(const Source& source, const std::string& str) {
     return {Token::Type::kReservedKeyword, source, "f16"};
   if (str == "f64")
     return {Token::Type::kReservedKeyword, source, "f64"};
-  if (str == "for")
-    return {Token::Type::kReservedKeyword, source, "for"};
   if (str == "i8")
     return {Token::Type::kReservedKeyword, source, "i8"};
   if (str == "i16")

src/reader/wgsl/lexer_test.cc

@@ -433,6 +433,7 @@ INSTANTIATE_TEST_SUITE_P(
                     TokenData{"fallthrough", Token::Type::kFallthrough},
                     TokenData{"false", Token::Type::kFalse},
                     TokenData{"fn", Token::Type::kFn},
+                    TokenData{"for", Token::Type::kFor},
                     TokenData{"fragment", Token::Type::kFragment},
                     TokenData{"function", Token::Type::kFunction},
                     TokenData{"i32", Token::Type::kI32},
@@ -492,7 +493,6 @@ INSTANTIATE_TEST_SUITE_P(LexerTest,
                                          "enum",
                                          "f16",
                                          "f64",
-                                         "for",
                                          "i8",
                                          "i16",
                                          "i64",

src/reader/wgsl/parser_impl.cc

@@ -1473,6 +1473,7 @@ std::unique_ptr<ast::BlockStatement> ParserImpl::statements() {
 //   | if_stmt
 //   | switch_stmt
 //   | loop_stmt
+//   | for_stmt
 //   | func_call_stmt SEMICOLON
 //   | variable_stmt SEMICOLON
 //   | break_stmt SEMICOLON
@@ -1517,6 +1518,12 @@ std::unique_ptr<ast::Statement> ParserImpl::statement() {
   if (loop != nullptr)
     return loop;
 
+  auto stmt_for = for_stmt();
+  if (has_error())
+    return nullptr;
+  if (stmt_for != nullptr)
+    return stmt_for;
+
   auto func = func_call_stmt();
   if (has_error())
     return nullptr;
@@ -1979,6 +1986,160 @@ std::unique_ptr<ast::LoopStatement> ParserImpl::loop_stmt() {
                                               std::move(continuing));
 }
 
+ForHeader::ForHeader(std::unique_ptr<ast::Statement> _initializer,
+                     std::unique_ptr<ast::Expression> _condition,
+                     std::unique_ptr<ast::Statement> _continuing)
+    : initializer(std::move(_initializer)),
+      condition(std::move(_condition)),
+      continuing(std::move(_continuing)) {}
+
+ForHeader::~ForHeader() = default;
+
+// for_header
+//   : (variable_stmt | assignment_stmt | func_call_stmt)?
+//   SEMICOLON
+//      logical_or_expression? SEMICOLON
+//      (assignment_stmt | func_call_stmt)?
+std::unique_ptr<ForHeader> ParserImpl::for_header() {
+  std::unique_ptr<ast::Statement> initializer = nullptr;
+  if (initializer == nullptr) {
+    initializer = func_call_stmt();
+    if (has_error()) {
+      return nullptr;
+    }
+  }
+  if (initializer == nullptr) {
+    initializer = variable_stmt();
+    if (has_error()) {
+      return nullptr;
+    }
+  }
+  if (initializer == nullptr) {
+    initializer = assignment_stmt();
+    if (has_error()) {
+      return nullptr;
+    }
+  }
+
+  auto t = next();
+  if (!t.IsSemicolon()) {
+    set_error(t, "missing ';' after initializer in for loop");
+    return nullptr;
+  }
+
+  auto condition = logical_or_expression();
+  if (has_error()) {
+    return nullptr;
+  }
+
+  t = next();
+  if (!t.IsSemicolon()) {
+    set_error(t, "missing ';' after condition in for loop");
+    return nullptr;
+  }
+
+  std::unique_ptr<ast::Statement> continuing = nullptr;
+  if (continuing == nullptr) {
+    continuing = func_call_stmt();
+    if (has_error()) {
+      return nullptr;
+    }
+  }
+  if (continuing == nullptr) {
+    continuing = assignment_stmt();
+    if (has_error()) {
+      return nullptr;
+    }
+  }
+
+  return std::make_unique<ForHeader>(
+      std::move(initializer), std::move(condition), std::move(continuing));
+}
+
+// for_statement
+//   : FOR PAREN_LEFT for_header PAREN_RIGHT BRACE_LEFT statements BRACE_RIGHT
+std::unique_ptr<ast::Statement> ParserImpl::for_stmt() {
+  auto t = peek();
+  if (!t.IsFor())
+    return nullptr;
+
+  auto source = t.source();
+  next();  // Consume the peek
+
+  t = next();
+  if (!t.IsParenLeft()) {
+    set_error(t, "missing for loop (");
+    return nullptr;
+  }
+
+  auto header = for_header();
+  if (has_error())
+    return nullptr;
+
+  t = next();
+  if (!t.IsParenRight()) {
+    set_error(t, "missing for loop )");
+    return nullptr;
+  }
+
+  t = next();
+  if (!t.IsBraceLeft()) {
+    set_error(t, "missing for loop {");
+    return nullptr;
+  }
+
+  auto body = statements();
+  if (has_error())
+    return nullptr;
+
+  t = next();
+  if (!t.IsBraceRight()) {
+    set_error(t, "missing for loop }");
+    return nullptr;
+  }
+
+  // The for statement is a syntactic sugar on top of the loop statement.
+  // We create corresponding nodes in ast with the exact same behaviour
+  // as we would expect from the loop statement.
+
+  if (header->condition != nullptr) {
+    // !condition
+    auto not_condition = std::make_unique<ast::UnaryOpExpression>(
+        header->condition->source(), ast::UnaryOp::kNot,
+        std::move(header->condition));
+    // { break; }
+    auto break_stmt =
+        std::make_unique<ast::BreakStatement>(not_condition->source());
+    auto break_body =
+        std::make_unique<ast::BlockStatement>(not_condition->source());
+    break_body->append(std::move(break_stmt));
+    // if (!condition) { break; }
+    auto break_if_not_condition = std::make_unique<ast::IfStatement>(
+        not_condition->source(), std::move(not_condition),
+        std::move(break_body));
+    body->insert(0, std::move(break_if_not_condition));
+  }
+
+  std::unique_ptr<ast::BlockStatement> continuing_body = nullptr;
+  if (header->continuing != nullptr) {
+    continuing_body =
+        std::make_unique<ast::BlockStatement>(header->continuing->source());
+    continuing_body->append(std::move(header->continuing));
+  }
+
+  auto loop = std::make_unique<ast::LoopStatement>(source, std::move(body),
+                                                   std::move(continuing_body));
+
+  if (header->initializer != nullptr) {
+    auto result = std::make_unique<ast::BlockStatement>(source);
+    result->append(std::move(header->initializer));
+    result->append(std::move(loop));
+    return result;
+  }
+
+  return loop;
+}
+
 // func_call_stmt
 //    : IDENT PAREN_LEFT argument_expression_list* PAREN_RIGHT
 std::unique_ptr<ast::CallStatement> ParserImpl::func_call_stmt() {

src/reader/wgsl/parser_impl.h

@@ -52,6 +52,18 @@ namespace wgsl {
 
 class Lexer;
 
+struct ForHeader {
+  std::unique_ptr<ast::Statement> initializer;
+  std::unique_ptr<ast::Expression> condition;
+  std::unique_ptr<ast::Statement> continuing;
+
+  ForHeader(std::unique_ptr<ast::Statement> _initializer,
+            std::unique_ptr<ast::Expression> _condition,
+            std::unique_ptr<ast::Statement> _continuing);
+
+  ~ForHeader();
+};
+
 /// ParserImpl for WGSL source data
 class ParserImpl {
  public:
@@ -227,6 +239,12 @@ class ParserImpl {
   /// Parses a `loop_stmt` grammar element
   /// @returns the parsed loop or nullptr
   std::unique_ptr<ast::LoopStatement> loop_stmt();
+  /// Parses a `for_header` grammar element
+  /// @returns the parsed for header or nullptr
+  std::unique_ptr<ForHeader> for_header();
+  /// Parses a `for_stmt` grammar element
+  /// @returns the parsed for loop or nullptr
+  std::unique_ptr<ast::Statement> for_stmt();
   /// Parses a `continuing_stmt` grammar element
   /// @returns the parsed statements
   std::unique_ptr<ast::BlockStatement> continuing_stmt();

src/reader/wgsl/parser_impl_for_stmt_test.cc

@@ -0,0 +1,286 @@
+// 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 "gtest/gtest.h"
+#include "src/reader/wgsl/parser_impl.h"
+#include "src/reader/wgsl/parser_impl_test_helper.h"
+
+#include <string>
+
+namespace tint {
+namespace reader {
+namespace wgsl {
+namespace {
+
+class ForStmtTest : public ParserImplTest {
+ public:
+  void TestForLoop(std::string loop_str, std::string for_str) {
+    auto* p_loop = parser(loop_str);
+    auto e_loop = p_loop->statements();
+    ASSERT_FALSE(p_loop->has_error()) << p_loop->error();
+    ASSERT_NE(e_loop, nullptr);
+
+    auto* p_for = parser(for_str);
+    auto e_for = p_for->statements();
+    ASSERT_FALSE(p_for->has_error()) << p_for->error();
+    ASSERT_NE(e_for, nullptr);
+
+    EXPECT_EQ(e_loop->str(), e_for->str());
+  }
+};
+
+// Test an empty for loop.
+TEST_F(ForStmtTest, Empty) {
+  std::string for_str = "for (;;) { }";
+  std::string loop_str = "loop { }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop with non-empty body.
+TEST_F(ForStmtTest, Body) {
+  std::string for_str = "for (;;) { discard; }";
+  std::string loop_str = "loop { discard; }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop declaring a variable in the initializer statement.
+TEST_F(ForStmtTest, InitializerStatementDecl) {
+  std::string for_str = "for (var i: i32 ;;) { }";
+  std::string loop_str = "{ var i: i32; loop { } }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop declaring and initializing a variable in the initializer
+// statement.
+TEST_F(ForStmtTest, InitializerStatementDeclEqual) {
+  std::string for_str = "for (var i: i32 = 0 ;;) { }";
+  std::string loop_str = "{ var i: i32 = 0; loop { } }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop declaring a const variable in the initializer statement.
+TEST_F(ForStmtTest, InitializerStatementConstDecl) {
+  std::string for_str = "for (const i: i32 = 0 ;;) { }";
+  std::string loop_str = "{ const i: i32 = 0; loop { } }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop assigning a variable in the initializer statement.
+TEST_F(ForStmtTest, InitializerStatementAssignment) {
+  std::string for_str = "var i: i32; for (i = 0 ;;) { }";
+  std::string loop_str = "var i: i32; { i = 0; loop { } }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop calling a function in the initializer statement.
+TEST_F(ForStmtTest, InitializerStatementFuncCall) {
+  std::string for_str = "for (a(b,c) ;;) { }";
+  std::string loop_str = "{ a(b,c); loop { } }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop with a break condition
+TEST_F(ForStmtTest, BreakCondition) {
+  std::string for_str = "for (; 0 == 1;) { }";
+  std::string loop_str = "loop { if (!(0 == 1)) { break; } }";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop assigning a variable in the continuing statement.
+TEST_F(ForStmtTest, ContinuingAssignment) {
+  std::string for_str = "var x: i32; for (;; x = 2) { }";
+  std::string loop_str = "var x: i32; loop { continuing { x = 2; }}";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop calling a function in the continuing statement.
+TEST_F(ForStmtTest, ContinuingFuncCall) {
+  std::string for_str = "for (;; a(b,c)) { }";
+  std::string loop_str = "loop { continuing { a(b,c); }}";
+
+  TestForLoop(loop_str, for_str);
+}
+
+// Test a for loop with all statements non-empty.
+TEST_F(ForStmtTest, All) {
+  std::string for_str =
+      R"(for(var i : i32 = 0; i < 4; i = i + 1) {
+       if (a == 0) {
+        continue;
+       }
+       a = a + 2;
+     })";
+
+  std::string loop_str =
+      R"({ # Introduce new scope for loop variable i
+      var i : i32 = 0;
+      loop {
+        if (!(i < 4)) {
+          break;
+        }
+
+        if (a == 0) {
+          continue;
+        }
+        a = a + 2;
+
+        continuing {
+          i = i + 1;
+        }
+      }
+    };)";
+
+  TestForLoop(loop_str, for_str);
+}
+
+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();
+
+    ASSERT_TRUE(p_for->has_error());
+    ASSERT_EQ(e_for, nullptr);
+    EXPECT_EQ(p_for->error(), error_str);
+  }
+};
+
+// Test a for loop with missing left parenthesis is invalid.
+TEST_F(ForStmtErrorTest, MissingLeftParen) {
+  std::string for_str = "for { }";
+  std::string error_str = "1:5: missing for loop (";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with missing first semicolon is invalid.
+TEST_F(ForStmtErrorTest, MissingFirstSemicolon) {
+  std::string for_str = "for () {}";
+  std::string error_str = "1:6: missing ';' after initializer in for loop";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with missing second semicolon is invalid.
+TEST_F(ForStmtErrorTest, MissingSecondSemicolon) {
+  std::string for_str = "for (;) {}";
+  std::string error_str = "1:7: missing ';' after condition in for loop";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with missing right parenthesis is invalid.
+TEST_F(ForStmtErrorTest, MissingRightParen) {
+  std::string for_str = "for (;; {}";
+  std::string error_str = "1:9: missing for loop )";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with missing left brace is invalid.
+TEST_F(ForStmtErrorTest, MissingLeftBrace) {
+  std::string for_str = "for (;;)";
+  std::string error_str = "1:9: missing for loop {";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with missing right brace is invalid.
+TEST_F(ForStmtErrorTest, MissingRightBrace) {
+  std::string for_str = "for (;;) {";
+  std::string error_str = "1:11: missing for loop }";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with an invalid initializer statement.
+TEST_F(ForStmtErrorTest, InvalidInitializerAsConstDecl) {
+  std::string for_str = "for (const x: i32;;) { }";
+  std::string error_str = "1:18: missing = for constant declaration";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with a initializer statement not matching
+// variable_stmt | assignment_stmt | func_call_stmt.
+TEST_F(ForStmtErrorTest, InvalidInitializerMatch) {
+  std::string for_str = "for (if (true) {} ;;) { }";
+  std::string error_str = "1:6: missing ';' after initializer in for loop";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with an invalid break condition.
+TEST_F(ForStmtErrorTest, InvalidBreakConditionAsExpression) {
+  std::string for_str = "for (; (0 == 1; ) { }";
+  std::string error_str = "1:15: expected )";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with a break condition not matching
+// logical_or_expression.
+TEST_F(ForStmtErrorTest, InvalidBreakConditionMatch) {
+  std::string for_str = "for (; var i: i32 = 0;) { }";
+  std::string error_str = "1:8: missing ';' after condition in for loop";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with an invalid continuing statement.
+TEST_F(ForStmtErrorTest, InvalidContinuingAsFuncCall) {
+  std::string for_str = "for (;; a(,) ) { }";
+  std::string error_str = "1:11: unable to parse argument expression";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with a continuing statement not matching
+// assignment_stmt | func_call_stmt.
+TEST_F(ForStmtErrorTest, InvalidContinuingMatch) {
+  std::string for_str = "for (;; var i: i32 = 0) { }";
+  std::string error_str = "1:9: missing for loop )";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with an invalid body.
+TEST_F(ForStmtErrorTest, InvalidBody) {
+  std::string for_str = "for (;;) { const x: i32; }";
+  std::string error_str = "1:24: missing = for constant declaration";
+
+  TestForWithError(for_str, error_str);
+}
+
+// Test a for loop with a body not matching statements
+TEST_F(ForStmtErrorTest, InvalidBodyMatch) {
+  std::string for_str = "for (;;) { fn main() -> void {} }";
+  std::string error_str = "1:12: missing for loop }";
+
+  TestForWithError(for_str, error_str);
+}
+
+}  // namespace
+}  // namespace wgsl
+}  // namespace reader
+}  // namespace tint

src/reader/wgsl/token.cc

@@ -149,6 +149,8 @@ std::string Token::TypeToName(Type type) {
       return "false";
     case Token::Type::kFn:
       return "fn";
+    case Token::Type::kFor:
+      return "for";
     case Token::Type::kFragment:
       return "fragment";
     case Token::Type::kFunction:

src/reader/wgsl/token.h

@@ -160,6 +160,8 @@ class Token {
     kFalse,
     /// A 'fn'
     kFn,
+    // A 'for'
+    kFor,
     /// A 'fragment'
     kFragment,
     /// A 'function'
@@ -415,6 +417,8 @@ class Token {
   bool IsFalse() const { return type_ == Type::kFalse; }
   /// @returns true if token is a 'fn'
   bool IsFn() const { return type_ == Type::kFn; }
+  /// @returns true if token is a 'for'
+  bool IsFor() const { return type_ == Type::kFor; }
   /// @returns true if token is a 'fragment'
   bool IsFragment() const { return type_ == Type::kFragment; }
   /// @returns true if token is a 'function'