Remove premerge.

This CL removes the premerge statement and replaces it with a `premerge`
reserved word.

Change-Id: Ic9bc13878ed26e1733eb65dd1ba30d9bef095cb6
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/19380
Reviewed-by: Ryan Harrison <rharrison@chromium.org>

src/reader/wgsl/lexer.cc

@@ -598,8 +598,6 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
     return {Token::Type::kOuterProduct, source, "outer_product"};
   if (str == "position")
     return {Token::Type::kPosition, source, "position"};
-  if (str == "premerge")
-    return {Token::Type::kPremerge, source, "premerge"};
   if (str == "private")
     return {Token::Type::kPrivate, source, "private"};
   if (str == "ptr")
@@ -673,6 +671,8 @@ Token Lexer::check_reserved(const Source& source, const std::string& str) {
     return {Token::Type::kReservedKeyword, source, "i64"};
   if (str == "let")
     return {Token::Type::kReservedKeyword, source, "let"};
+  if (str == "premerge")
+    return {Token::Type::kReservedKeyword, source, "premerge"};
   if (str == "typedef")
     return {Token::Type::kReservedKeyword, source, "typedef"};
   if (str == "u8")

src/reader/wgsl/lexer_test.cc

@@ -474,7 +474,6 @@ INSTANTIATE_TEST_SUITE_P(
         TokenData{"out", Token::Type::kOut},
         TokenData{"outer_product", Token::Type::kOuterProduct},
         TokenData{"position", Token::Type::kPosition},
-        TokenData{"premerge", Token::Type::kPremerge},
         TokenData{"private", Token::Type::kPrivate},
         TokenData{"ptr", Token::Type::kPtr},
         TokenData{"push_constant", Token::Type::kPushConstant},
@@ -521,6 +520,7 @@ INSTANTIATE_TEST_SUITE_P(LexerTest,
                                          "i16",
                                          "i64",
                                          "let",
+                                         "premerge",
                                          "typedef",
                                          "u8",
                                          "u16",

src/reader/wgsl/parser_impl.cc

@@ -1720,7 +1720,7 @@ std::unique_ptr<ast::VariableDeclStatement> ParserImpl::variable_stmt() {
 
 // if_stmt
 //   : IF paren_rhs_stmt body_stmt
-//           {(elseif_stmt else_stmt?) | (else_stmt premerge_stmt?)}
+//           {(elseif_stmt else_stmt?) | (else_stmt?)}
 std::unique_ptr<ast::IfStatement> ParserImpl::if_stmt() {
   auto t = peek();
   if (!t.IsIf())
@@ -1758,13 +1758,6 @@ std::unique_ptr<ast::IfStatement> ParserImpl::if_stmt() {
   auto stmt = std::make_unique<ast::IfStatement>(source, std::move(condition),
                                                  std::move(body));
   if (el != nullptr) {
-    if (elseif.size() == 0) {
-      auto premerge = premerge_stmt();
-      if (has_error())
-        return nullptr;
-
-      stmt->set_premerge(std::move(premerge));
-    }
     elseif.push_back(std::move(el));
   }
   stmt->set_else_statements(std::move(elseif));
@@ -1836,17 +1829,6 @@ std::unique_ptr<ast::ElseStatement> ParserImpl::else_stmt() {
   return std::make_unique<ast::ElseStatement>(source, std::move(body));
 }
 
-// premerge_stmt
-//   : PREMERGE body_stmt
-ast::StatementList ParserImpl::premerge_stmt() {
-  auto t = peek();
-  if (!t.IsPremerge())
-    return {};
-
-  next();  // Consume the peek
-  return body_stmt();
-}
-
 // unless_stmt
 //   : UNLESS paren_rhs_stmt body_stmt
 std::unique_ptr<ast::UnlessStatement> ParserImpl::unless_stmt() {

src/reader/wgsl/parser_impl.h

@@ -208,9 +208,6 @@ class ParserImpl {
   /// Parses a `else_stmt` grammar element
   /// @returns the parsed statement or nullptr
   std::unique_ptr<ast::ElseStatement> else_stmt();
-  /// Parses a `premerge_stmt` grammar element
-  /// @returns the parsed statements
-  ast::StatementList premerge_stmt();
   /// Parses a `unless_stmt` grammar element
   /// @returns the parsed element or nullptr
   std::unique_ptr<ast::UnlessStatement> unless_stmt();

src/reader/wgsl/parser_impl_if_stmt_test.cc

@@ -34,7 +34,6 @@ TEST_F(ParserImplTest, IfStmt) {
   ASSERT_TRUE(e->condition()->IsBinary());
   EXPECT_EQ(e->body().size(), 2);
   EXPECT_EQ(e->else_statements().size(), 0);
-  EXPECT_EQ(e->premerge().size(), 0);
 }
 
 TEST_F(ParserImplTest, IfStmt_WithElse) {
@@ -57,31 +56,6 @@ TEST_F(ParserImplTest, IfStmt_WithElse) {
   EXPECT_EQ(e->else_statements()[1]->body().size(), 0);
 }
 
-TEST_F(ParserImplTest, IfStmt_WithPremerge) {
-  auto p = parser(R"(if (a == 4) {
-  a = b;
-  c = d;
-} else {
-  d = 2;
-} premerge {
-  a = 2;
-})");
-  auto e = p->if_stmt();
-  ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_NE(e, nullptr);
-
-  ASSERT_TRUE(e->IsIf());
-  ASSERT_NE(e->condition(), nullptr);
-  ASSERT_TRUE(e->condition()->IsBinary());
-  EXPECT_EQ(e->body().size(), 2);
-
-  ASSERT_EQ(e->else_statements().size(), 1);
-  ASSERT_EQ(e->else_statements()[0]->condition(), nullptr);
-  EXPECT_EQ(e->else_statements()[0]->body().size(), 1);
-
-  ASSERT_EQ(e->premerge().size(), 1);
-}
-
 TEST_F(ParserImplTest, IfStmt_InvalidCondition) {
   auto p = parser("if (a = 3) {}");
   auto e = p->if_stmt();
@@ -130,14 +104,6 @@ TEST_F(ParserImplTest, IfStmt_InvalidElse) {
   EXPECT_EQ(p->error(), "1:18: missing }");
 }
 
-TEST_F(ParserImplTest, IfStmt_InvalidPremerge) {
-  auto p = parser("if (a) {} else {} premerge { fn main() -> a{}}");
-  auto e = p->if_stmt();
-  ASSERT_TRUE(p->has_error());
-  ASSERT_EQ(e, nullptr);
-  EXPECT_EQ(p->error(), "1:30: missing }");
-}
-
 }  // namespace
 }  // namespace wgsl
 }  // namespace reader

src/reader/wgsl/parser_impl_premerge_stmt_test.cc

@@ -1,43 +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 "gtest/gtest.h"
-#include "src/reader/wgsl/parser_impl.h"
-#include "src/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint {
-namespace reader {
-namespace wgsl {
-namespace {
-
-TEST_F(ParserImplTest, PremergeStmt) {
-  auto p = parser("premerge { nop; }");
-  auto e = p->premerge_stmt();
-  ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 1);
-  ASSERT_TRUE(e[0]->IsNop());
-}
-
-TEST_F(ParserImplTest, PremergeStmt_InvalidBody) {
-  auto p = parser("premerge { nop }");
-  auto e = p->premerge_stmt();
-  ASSERT_TRUE(p->has_error());
-  ASSERT_EQ(e.size(), 0);
-  EXPECT_EQ(p->error(), "1:16: missing ;");
-}
-
-}  // namespace
-}  // namespace wgsl
-}  // namespace reader
-}  // namespace tint

src/reader/wgsl/token.h

@@ -561,8 +561,6 @@ class Token {
   bool IsOuterProduct() const { return type_ == Type::kOuterProduct; }
   /// @returns true if token is a 'position'
   bool IsPosition() const { return type_ == Type::kPosition; }
-  /// @returns true if token is a 'premerge'
-  bool IsPremerge() const { return type_ == Type::kPremerge; }
   /// @returns true if token is a 'private'
   bool IsPrivate() const { return type_ == Type::kPrivate; }
   /// @returns true if token is a 'ptr'