reader/wgsl: Reserve ++ and -- tokens

Fixed: tint:971
Change-Id: I70732db7b22f7785866066cd7966eec630078de0
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/57761
Auto-Submit: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: James Price <jrprice@google.com>

src/reader/wgsl/lexer.cc

@@ -423,6 +423,10 @@ Token Lexer::try_punctuation() {
     type = Token::Type::kArrow;
     pos_ += 2;
     location_.column += 2;
+  } else if (matches(pos_, "--")) {
+    type = Token::Type::kMinusMinus;
+    pos_ += 2;
+    location_.column += 2;
   } else if (matches(pos_, "-")) {
     type = Token::Type::kMinus;
     pos_ += 1;
@@ -431,6 +435,10 @@ Token Lexer::try_punctuation() {
     type = Token::Type::kPeriod;
     pos_ += 1;
     location_.column += 1;
+  } else if (matches(pos_, "++")) {
+    type = Token::Type::kPlusPlus;
+    pos_ += 2;
+    location_.column += 2;
   } else if (matches(pos_, "+")) {
     type = Token::Type::kPlus;
     pos_ += 1;

src/reader/wgsl/lexer_test.cc

@@ -387,8 +387,10 @@ INSTANTIATE_TEST_SUITE_P(
                     TokenData{"%", Token::Type::kMod},
                     TokenData{"!=", Token::Type::kNotEqual},
                     TokenData{"-", Token::Type::kMinus},
+                    TokenData{"--", Token::Type::kMinusMinus},
                     TokenData{".", Token::Type::kPeriod},
                     TokenData{"+", Token::Type::kPlus},
+                    TokenData{"++", Token::Type::kPlusPlus},
                     TokenData{"|", Token::Type::kOr},
                     TokenData{"||", Token::Type::kOrOr},
                     TokenData{"(", Token::Type::kParenLeft},

src/reader/wgsl/parser_impl.cc

@@ -2223,6 +2223,15 @@ Maybe<ast::Expression*> ParserImpl::primary_expression() {
 Maybe<ast::Expression*> ParserImpl::postfix_expression(
     ast::Expression* prefix) {
   Source source;
+
+  if (match(Token::Type::kPlusPlus, &source) ||
+      match(Token::Type::kMinusMinus, &source)) {
+    add_error(source,
+              "postfix increment and decrement operators are reserved for a "
+              "future WGSL version");
+    return Failure::kErrored;
+  }
+
   if (match(Token::Type::kBracketLeft, &source)) {
     return sync(Token::Type::kBracketRight, [&]() -> Maybe<ast::Expression*> {
       auto param = logical_or_expression();
@@ -2299,6 +2308,13 @@ Expect<ast::ExpressionList> ParserImpl::expect_argument_expression_list(
 Maybe<ast::Expression*> ParserImpl::unary_expression() {
   auto t = peek();
 
+  if (match(Token::Type::kPlusPlus) || match(Token::Type::kMinusMinus)) {
+    add_error(t.source(),
+              "prefix increment and decrement operators are reserved for a "
+              "future WGSL version");
+    return Failure::kErrored;
+  }
+
   ast::UnaryOp op;
   if (match(Token::Type::kMinus)) {
     op = ast::UnaryOp::kNegation;

src/reader/wgsl/parser_impl_singular_expression_test.cc

@@ -236,6 +236,30 @@ TEST_F(ParserImplTest, SingularExpression_Array_NestedArrayAccessor) {
   EXPECT_EQ(index_expr->symbol(), p->builder().Symbols().Get("c"));
 }
 
+TEST_F(ParserImplTest, SingularExpression_PostfixPlusPlus) {
+  auto p = parser("a++");
+  auto e = p->singular_expression();
+  EXPECT_FALSE(e.matched);
+  EXPECT_TRUE(e.errored);
+  EXPECT_EQ(e.value, nullptr);
+  EXPECT_TRUE(p->has_error());
+  EXPECT_EQ(p->error(),
+            "1:2: postfix increment and decrement operators are reserved for a "
+            "future WGSL version");
+}
+
+TEST_F(ParserImplTest, SingularExpression_PostfixMinusMinus) {
+  auto p = parser("a--");
+  auto e = p->singular_expression();
+  EXPECT_FALSE(e.matched);
+  EXPECT_TRUE(e.errored);
+  EXPECT_EQ(e.value, nullptr);
+  EXPECT_TRUE(p->has_error());
+  EXPECT_EQ(p->error(),
+            "1:2: postfix increment and decrement operators are reserved for a "
+            "future WGSL version");
+}
+
 }  // namespace
 }  // namespace wgsl
 }  // namespace reader

src/reader/wgsl/parser_impl_unary_expression_test.cc

@@ -177,6 +177,30 @@ TEST_F(ParserImplTest, UnaryExpression_Tilde) {
   EXPECT_EQ(init->literal()->As<ast::SintLiteral>()->value(), 1);
 }
 
+TEST_F(ParserImplTest, UnaryExpression_PrefixPlusPlus) {
+  auto p = parser("++a");
+  auto e = p->unary_expression();
+  EXPECT_FALSE(e.matched);
+  EXPECT_TRUE(e.errored);
+  EXPECT_EQ(e.value, nullptr);
+  EXPECT_TRUE(p->has_error());
+  EXPECT_EQ(p->error(),
+            "1:1: prefix increment and decrement operators are reserved for a "
+            "future WGSL version");
+}
+
+TEST_F(ParserImplTest, UnaryExpression_PrefixMinusMinus) {
+  auto p = parser("--a");
+  auto e = p->unary_expression();
+  EXPECT_FALSE(e.matched);
+  EXPECT_TRUE(e.errored);
+  EXPECT_EQ(e.value, nullptr);
+  EXPECT_TRUE(p->has_error());
+  EXPECT_EQ(p->error(),
+            "1:1: prefix increment and decrement operators are reserved for a "
+            "future WGSL version");
+}
+
 }  // namespace
 }  // namespace wgsl
 }  // namespace reader

src/reader/wgsl/token.cc

@@ -84,10 +84,14 @@ std::string Token::TypeToName(Type type) {
       return "!=";
     case Token::Type::kMinus:
       return "-";
+    case Token::Type::kMinusMinus:
+      return "--";
     case Token::Type::kPeriod:
       return ".";
     case Token::Type::kPlus:
       return "+";
+    case Token::Type::kPlusPlus:
+      return "++";
     case Token::Type::kOr:
       return "|";
     case Token::Type::kOrOr:

src/reader/wgsl/token.h

@@ -90,12 +90,16 @@ class Token {
     kMod,
     /// A '-'
     kMinus,
+    /// A '--'
+    kMinusMinus,
     /// A '!='
     kNotEqual,
     /// A '.'
     kPeriod,
     /// A '+'
     kPlus,
+    /// A '++'
+    kPlusPlus,
     /// A '|'
     kOr,
     /// A '||'