Remove KillStatement

This CL removes the KillStatement from the AST and replaces all test
usage with DiscardStatement.

Bug: tint:169
Change-Id: Ie68dd3cdd54056f144d10506f05cc1f6903d1cda
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/25605
Reviewed-by: David Neto <dneto@google.com>

src/reader/spirv/function.cc

@@ -2192,7 +2192,7 @@ bool FunctionEmitter::EmitNormalTerminator(const BlockInfo& block_info) {
     }
       return true;
     case SpvOpKill:
-      // For now, assume SPIR-V OpKill has same semantics as WGSL kill.
+      // For now, assume SPIR-V OpKill has same semantics as WGSL discard.
       // TODO(dneto): https://github.com/gpuweb/gpuweb/issues/676
       AddStatement(std::make_unique<ast::DiscardStatement>());
       return true;

src/reader/wgsl/lexer.cc

@@ -527,8 +527,6 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
     return {Token::Type::kImport, source, "import"};
   if (str == "in")
     return {Token::Type::kIn, source, "in"};
-  if (str == "kill")
-    return {Token::Type::kKill, source, "kill"};
   if (str == "location")
     return {Token::Type::kLocation, source, "location"};
   if (str == "loop")

src/reader/wgsl/lexer_test.cc

@@ -440,7 +440,6 @@ INSTANTIATE_TEST_SUITE_P(
                     TokenData{"image", Token::Type::kImage},
                     TokenData{"import", Token::Type::kImport},
                     TokenData{"in", Token::Type::kIn},
-                    TokenData{"kill", Token::Type::kKill},
                     TokenData{"location", Token::Type::kLocation},
                     TokenData{"loop", Token::Type::kLoop},
                     TokenData{"mat2x2", Token::Type::kMat2x2},

src/reader/wgsl/parser_impl.cc

@@ -35,7 +35,6 @@
 #include "src/ast/float_literal.h"
 #include "src/ast/identifier_expression.h"
 #include "src/ast/if_statement.h"
-#include "src/ast/kill_statement.h"
 #include "src/ast/location_decoration.h"
 #include "src/ast/member_accessor_expression.h"
 #include "src/ast/return_statement.h"
@@ -1428,7 +1427,6 @@ ast::StatementList ParserImpl::statements() {
 //   | break_stmt SEMICOLON
 //   | continue_stmt SEMICOLON
 //   | DISCARD SEMICOLON
-//   | KILL SEMICOLON
 //   | assignment_stmt SEMICOLON
 std::unique_ptr<ast::Statement> ParserImpl::statement() {
   auto t = peek();
@@ -1527,18 +1525,6 @@ std::unique_ptr<ast::Statement> ParserImpl::statement() {
     return std::make_unique<ast::DiscardStatement>(source);
   }
 
-  if (t.IsKill()) {
-    auto source = t.source();
-    next();  // Consume the peek
-
-    t = next();
-    if (!t.IsSemicolon()) {
-      set_error(t, "missing ;");
-      return nullptr;
-    }
-    return std::make_unique<ast::KillStatement>(source);
-  }
-
   auto assign = assignment_stmt();
   if (has_error())
     return nullptr;

src/reader/wgsl/parser_impl_body_stmt_test.cc

@@ -23,13 +23,13 @@ namespace {
 
 TEST_F(ParserImplTest, BodyStmt) {
   auto* p = parser(R"({
-  kill;
+  discard;
   return 1 + b / 2;
 })");
   auto e = p->body_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e.size(), 2u);
-  EXPECT_TRUE(e[0]->IsKill());
+  EXPECT_TRUE(e[0]->IsDiscard());
   EXPECT_TRUE(e[1]->IsReturn());
 }
 

src/reader/wgsl/parser_impl_continuing_stmt_test.cc

@@ -22,19 +22,19 @@ namespace wgsl {
 namespace {
 
 TEST_F(ParserImplTest, ContinuingStmt) {
-  auto* p = parser("continuing { kill; }");
+  auto* p = parser("continuing { discard; }");
   auto e = p->continuing_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e.size(), 1u);
-  ASSERT_TRUE(e[0]->IsKill());
+  ASSERT_TRUE(e[0]->IsDiscard());
 }
 
 TEST_F(ParserImplTest, ContinuingStmt_InvalidBody) {
-  auto* p = parser("continuing { kill }");
+  auto* p = parser("continuing { discard }");
   auto e = p->continuing_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e.size(), 0u);
-  EXPECT_EQ(p->error(), "1:19: missing ;");
+  EXPECT_EQ(p->error(), "1:22: missing ;");
 }
 
 }  // namespace

src/reader/wgsl/parser_impl_loop_stmt_test.cc

@@ -22,28 +22,28 @@ namespace wgsl {
 namespace {
 
 TEST_F(ParserImplTest, LoopStmt_BodyNoContinuing) {
-  auto* p = parser("loop { kill; }");
+  auto* p = parser("loop { discard; }");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_EQ(e->body().size(), 1u);
-  EXPECT_TRUE(e->body()[0]->IsKill());
+  EXPECT_TRUE(e->body()[0]->IsDiscard());
 
   EXPECT_EQ(e->continuing().size(), 0u);
 }
 
 TEST_F(ParserImplTest, LoopStmt_BodyWithContinuing) {
-  auto* p = parser("loop { kill; continuing { kill; }}");
+  auto* p = parser("loop { discard; continuing { discard; }}");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_EQ(e->body().size(), 1u);
-  EXPECT_TRUE(e->body()[0]->IsKill());
+  EXPECT_TRUE(e->body()[0]->IsDiscard());
 
   EXPECT_EQ(e->continuing().size(), 1u);
-  EXPECT_TRUE(e->continuing()[0]->IsKill());
+  EXPECT_TRUE(e->continuing()[0]->IsDiscard());
 }
 
 TEST_F(ParserImplTest, LoopStmt_NoBodyNoContinuing) {
@@ -56,17 +56,17 @@ TEST_F(ParserImplTest, LoopStmt_NoBodyNoContinuing) {
 }
 
 TEST_F(ParserImplTest, LoopStmt_NoBodyWithContinuing) {
-  auto* p = parser("loop { continuing { kill; }}");
+  auto* p = parser("loop { continuing { discard; }}");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_EQ(e->body().size(), 0u);
   ASSERT_EQ(e->continuing().size(), 1u);
-  EXPECT_TRUE(e->continuing()[0]->IsKill());
+  EXPECT_TRUE(e->continuing()[0]->IsDiscard());
 }
 
 TEST_F(ParserImplTest, LoopStmt_MissingBracketLeft) {
-  auto* p = parser("loop kill; }");
+  auto* p = parser("loop discard; }");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -74,27 +74,27 @@ TEST_F(ParserImplTest, LoopStmt_MissingBracketLeft) {
 }
 
 TEST_F(ParserImplTest, LoopStmt_MissingBracketRight) {
-  auto* p = parser("loop { kill; ");
+  auto* p = parser("loop { discard; ");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
-  EXPECT_EQ(p->error(), "1:14: missing } for loop");
+  EXPECT_EQ(p->error(), "1:17: missing } for loop");
 }
 
 TEST_F(ParserImplTest, LoopStmt_InvalidStatements) {
-  auto* p = parser("loop { kill }");
+  auto* p = parser("loop { discard }");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
-  EXPECT_EQ(p->error(), "1:13: missing ;");
+  EXPECT_EQ(p->error(), "1:16: missing ;");
 }
 
 TEST_F(ParserImplTest, LoopStmt_InvalidContinuing) {
-  auto* p = parser("loop { continuing { kill }}");
+  auto* p = parser("loop { continuing { discard }}");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
-  EXPECT_EQ(p->error(), "1:26: missing ;");
+  EXPECT_EQ(p->error(), "1:29: missing ;");
 }
 
 }  // namespace

src/reader/wgsl/parser_impl_statement_test.cc

@@ -142,7 +142,7 @@ TEST_F(ParserImplTest, Statement_Loop) {
 }
 
 TEST_F(ParserImplTest, Statement_Loop_Invalid) {
-  auto* p = parser("loop kill; }");
+  auto* p = parser("loop discard; }");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -205,22 +205,6 @@ TEST_F(ParserImplTest, Statement_Continue_MissingSemicolon) {
   EXPECT_EQ(p->error(), "1:9: missing ;");
 }
 
-TEST_F(ParserImplTest, Statement_Kill) {
-  auto* p = parser("kill;");
-  auto e = p->statement();
-  ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_NE(e, nullptr);
-  ASSERT_TRUE(e->IsKill());
-}
-
-TEST_F(ParserImplTest, Statement_Kill_MissingSemicolon) {
-  auto* p = parser("kill");
-  auto e = p->statement();
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(e, nullptr);
-  EXPECT_EQ(p->error(), "1:5: missing ;");
-}
-
 TEST_F(ParserImplTest, Statement_Discard) {
   auto* p = parser("discard;");
   auto e = p->statement();

src/reader/wgsl/parser_impl_statements_test.cc

@@ -23,11 +23,11 @@ namespace wgsl {
 namespace {
 
 TEST_F(ParserImplTest, Statements) {
-  auto* p = parser("kill; return;");
+  auto* p = parser("discard; return;");
   auto e = p->statements();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e.size(), 2u);
-  EXPECT_TRUE(e[0]->IsKill());
+  EXPECT_TRUE(e[0]->IsDiscard());
   EXPECT_TRUE(e[1]->IsReturn());
 }
 

src/reader/wgsl/token.cc

@@ -163,8 +163,6 @@ std::string Token::TypeToName(Type type) {
       return "import";
     case Token::Type::kIn:
       return "in";
-    case Token::Type::kKill:
-      return "kill";
     case Token::Type::kLocation:
       return "location";
     case Token::Type::kLoop:

src/reader/wgsl/token.h

@@ -174,8 +174,6 @@ class Token {
     kImport,
     /// A 'in'
     kIn,
-    /// A 'kill'
-    kKill,
     /// A 'location'
     kLocation,
     /// A 'loop'
@@ -429,8 +427,6 @@ class Token {
   bool IsImport() const { return type_ == Type::kImport; }
   /// @returns true if token is a 'in'
   bool IsIn() const { return type_ == Type::kIn; }
-  /// @returns true if token is a 'kill'
-  bool IsKill() const { return type_ == Type::kKill; }
   /// @returns true if token is a 'location'
   bool IsLocation() const { return type_ == Type::kLocation; }
   /// @returns true if token is a 'loop'