src/tint/reader/wgsl/parser_impl_expression_test.cc - tint - Git at Google

 // Copyright 2022 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 "src/tint/reader/wgsl/parser_impl_test_helper.h"

 namespace tint::reader::wgsl {
 namespace {

 TEST_F(ParserImplTest, Expression_InvalidLHS) {
     auto p = parser("if (a) {} || true");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     EXPECT_EQ(e.value, nullptr);
 }

 TEST_F(ParserImplTest, Expression_Or_Parses) {
     auto p = parser("a || true");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     EXPECT_EQ(e->source.range.begin.line, 1u);
     EXPECT_EQ(e->source.range.begin.column, 3u);
     EXPECT_EQ(e->source.range.end.line, 1u);
     EXPECT_EQ(e->source.range.end.column, 5u);

     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     auto* rel = e->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);

     ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
     auto* ident = rel->lhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

     ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
     ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
 }

 TEST_F(ParserImplTest, Expression_Or_Parses_Multiple) {
     auto p = parser("a || true || b");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     // lhs: (a || true)
     // rhs: b
     auto* rel = e->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);

     ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
     auto* ident = rel->rhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));

     ASSERT_TRUE(rel->lhs->Is<ast::BinaryExpression>());
     // lhs: a
     // rhs: true
     rel = rel->lhs->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);

     ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
     ident = rel->lhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

     ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
     ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
 }

 TEST_F(ParserImplTest, Expression_Or_InvalidRHS) {
     auto p = parser("true || if (a) {}");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(p->error(), "1:9: unable to parse right side of || expression");
 }

 TEST_F(ParserImplTest, Expression_And_Parses) {
     auto p = parser("a && true");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     EXPECT_EQ(e->source.range.begin.line, 1u);
     EXPECT_EQ(e->source.range.begin.column, 3u);
     EXPECT_EQ(e->source.range.end.line, 1u);
     EXPECT_EQ(e->source.range.end.column, 5u);

     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     auto* rel = e->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op);

     ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
     auto* ident = rel->lhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

     ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
     ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
 }

 TEST_F(ParserImplTest, Expression_And_Parses_Multple) {
     auto p = parser("a && true && b");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     // lhs: (a && true)
     // rhs: b
     auto* rel = e->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op);

     ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
     auto* ident = rel->rhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));

     ASSERT_TRUE(rel->lhs->Is<ast::BinaryExpression>());
     // lhs: a
     // rhs: true
     rel = rel->lhs->As<ast::BinaryExpression>();
     ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
     ident = rel->lhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

     ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
     ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
 }

 TEST_F(ParserImplTest, Expression_And_InvalidRHS) {
     auto p = parser("true && if (a) {}");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(p->error(), "1:9: unable to parse right side of && expression");
 }

 TEST_F(ParserImplTest, Expression_Mixing_OrWithAnd) {
     auto p = parser("a && true || b");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(p->error(), "1:3: mixing '&&' and '||' requires parenthesis");
 }

 TEST_F(ParserImplTest, Expression_Mixing_AndWithOr) {
     auto p = parser("a || true && b");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(p->error(), "1:3: mixing '||' and '&&' requires parenthesis");
 }

 TEST_F(ParserImplTest, Expression_Bitwise) {
     auto p = parser("a & b");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     auto* rel = e->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kAnd, rel->op);

     ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
     auto* ident = rel->lhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

     ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
     ident = rel->rhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));
 }

 TEST_F(ParserImplTest, Expression_Relational) {
     auto p = parser("a <= b");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     auto* rel = e->As<ast::BinaryExpression>();
     EXPECT_EQ(ast::BinaryOp::kLessThanEqual, rel->op);

     ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
     auto* ident = rel->lhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

     ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
     ident = rel->rhs->As<ast::IdentifierExpression>();
     EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));
 }

 TEST_F(ParserImplTest, Expression_InvalidUnary) {
     auto p = parser("!if || true");
     auto e = p->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: unable to parse right side of ! expression");
 }

 TEST_F(ParserImplTest, Expression_InvalidBitwise) {
     auto p = parser("a & if");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(p->error(), "1:5: unable to parse right side of & expression");
 }

 TEST_F(ParserImplTest, Expression_InvalidRelational) {
     auto p = parser("a <= if");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_EQ(e.value, nullptr);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(p->error(), "1:6: unable to parse right side of <= expression");
 }

 TEST_F(ParserImplTest, Expression_Associativity) {
     auto p = parser("1 < 2 || 2 < 3");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);
 }

 TEST_F(ParserImplTest, Expression_InvalidAssociativity) {
     auto p = parser("1 < 2 && 2 < 3 || 3 < 4");
     auto e = p->expression();
     EXPECT_FALSE(e.matched);
     EXPECT_TRUE(e.errored);
     EXPECT_TRUE(p->has_error());
     EXPECT_EQ(e.value, nullptr);
     EXPECT_EQ(p->error(), R"(1:7: mixing '&&' and '||' requires parenthesis)");
 }

 TEST_F(ParserImplTest, Expression_SubtractionNoSpace) {
     auto p = parser("(2-1)");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);
     ASSERT_TRUE(e->Is<ast::BinaryExpression>());
     auto* b = e->As<ast::BinaryExpression>();
     EXPECT_TRUE(b->IsSubtract());

     ASSERT_TRUE(b->lhs->Is<ast::IntLiteralExpression>());
     ASSERT_TRUE(b->rhs->Is<ast::IntLiteralExpression>());

     EXPECT_EQ(b->lhs->As<ast::IntLiteralExpression>()->value, 2);
     EXPECT_EQ(b->rhs->As<ast::IntLiteralExpression>()->value, 1);
 }

 TEST_F(ParserImplTest, Expression_NegatedNumber) {
     auto p = parser("-1");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
     auto* b = e->As<ast::UnaryOpExpression>();
     EXPECT_EQ(b->op, ast::UnaryOp::kNegation);

     ASSERT_TRUE(b->expr->Is<ast::IntLiteralExpression>());
     EXPECT_EQ(b->expr->As<ast::IntLiteralExpression>()->value, 1);
 }

 TEST_F(ParserImplTest, Expression_MaxI32) {
     auto p = parser("2147483647");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::IntLiteralExpression>());
     EXPECT_EQ(e->As<ast::IntLiteralExpression>()->value, 2147483647);
 }

 TEST_F(ParserImplTest, Expression_MinI32) {
     auto p = parser("-2147483648");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
     auto* b = e->As<ast::UnaryOpExpression>();
     EXPECT_EQ(b->op, ast::UnaryOp::kNegation);

     ASSERT_TRUE(b->expr->Is<ast::IntLiteralExpression>());
     EXPECT_EQ(b->expr->As<ast::IntLiteralExpression>()->value, 2147483648);
 }

 TEST_F(ParserImplTest, Expression_MaxU32) {
     auto p = parser("4294967295");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::IntLiteralExpression>());
     EXPECT_EQ(e->As<ast::IntLiteralExpression>()->value, 4294967295);
 }

 TEST_F(ParserImplTest, Expression_MaxF32) {
     const auto highest = std::numeric_limits<float>::max();
     const auto expected_highest = 340282346638528859811704183484516925440.0f;
     if (highest < expected_highest || highest > expected_highest) {
         GTEST_SKIP() << "std::numeric_limits<float>::max() is not as expected for "
                         "this target";
     }

     auto p = parser("340282346638528859811704183484516925440.0f");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::FloatLiteralExpression>());
     EXPECT_EQ(e->As<ast::FloatLiteralExpression>()->value,
               340282346638528859811704183484516925440.0f);
 }

 TEST_F(ParserImplTest, Expression_MinF32) {
     const auto lowest = std::numeric_limits<float>::lowest();
     const auto expected_lowest = -340282346638528859811704183484516925440.0f;
     if (lowest < expected_lowest || lowest > expected_lowest) {
         GTEST_SKIP() << "std::numeric_limits<float>::lowest() is not as expected for "
                         "this target";
     }

     auto p = parser("-340282346638528859811704183484516925440.0f");
     auto e = p->expression();
     EXPECT_TRUE(e.matched);
     EXPECT_FALSE(e.errored);
     EXPECT_FALSE(p->has_error()) << p->error();
     ASSERT_NE(e.value, nullptr);

     ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
     auto* b = e->As<ast::UnaryOpExpression>();
     EXPECT_EQ(b->op, ast::UnaryOp::kNegation);

     ASSERT_TRUE(b->expr->Is<ast::FloatLiteralExpression>());
     EXPECT_EQ(b->expr->As<ast::FloatLiteralExpression>()->value,
               340282346638528859811704183484516925440.0f);
 }

 namespace mixing_binary_ops {

 struct BinaryOperatorInfo {
     // A uint64_t with a single bit assigned that uniquely identifies the binary-op.
     uint64_t bit;
     // The WGSL operator symbol. Example: '<='
     const char* symbol;
     // A bit mask of all operators that can immediately follow the RHS of this operator without
     // requiring parentheses. In other words, `can_follow_without_paren` is the full set of
     // operators that can substitute `<next-operator>` in the WGSL:
     //   `expr_a <this-operator> expr_b <next-operator> expr_c`
     // without requiring additional parentheses.
     uint64_t can_follow_without_paren;
 };

 // Each binary operator is given a unique bit in a uint64_t
 static constexpr uint64_t kOpMul = static_cast<uint64_t>(1) << 0;
 static constexpr uint64_t kOpDiv = static_cast<uint64_t>(1) << 1;
 static constexpr uint64_t kOpMod = static_cast<uint64_t>(1) << 2;
 static constexpr uint64_t kOpAdd = static_cast<uint64_t>(1) << 3;
 static constexpr uint64_t kOpSub = static_cast<uint64_t>(1) << 4;
 static constexpr uint64_t kOpBAnd = static_cast<uint64_t>(1) << 5;
 static constexpr uint64_t kOpBOr = static_cast<uint64_t>(1) << 6;
 static constexpr uint64_t kOpBXor = static_cast<uint64_t>(1) << 7;
 static constexpr uint64_t kOpShl = static_cast<uint64_t>(1) << 8;
 static constexpr uint64_t kOpShr = static_cast<uint64_t>(1) << 9;
 static constexpr uint64_t kOpLt = static_cast<uint64_t>(1) << 10;
 static constexpr uint64_t kOpGt = static_cast<uint64_t>(1) << 11;
 static constexpr uint64_t kOpLe = static_cast<uint64_t>(1) << 12;
 static constexpr uint64_t kOpGe = static_cast<uint64_t>(1) << 13;
 static constexpr uint64_t kOpEq = static_cast<uint64_t>(1) << 14;
 static constexpr uint64_t kOpNe = static_cast<uint64_t>(1) << 15;
 static constexpr uint64_t kOpLAnd = static_cast<uint64_t>(1) << 16;
 static constexpr uint64_t kOpLOr = static_cast<uint64_t>(1) << 17;

 // Bit mask for the binary operator groups
 static constexpr uint64_t kMultiplicative = kOpMul | kOpDiv | kOpMod;
 static constexpr uint64_t kAdditive = kOpAdd | kOpSub;
 static constexpr uint64_t kShift = kOpShl | kOpShr;
 static constexpr uint64_t kRelational = kOpLt | kOpGt | kOpLe | kOpGe | kOpEq | kOpNe;
 static constexpr uint64_t kLogical = kOpLAnd | kOpLOr;

 // The binary operator table
 static constexpr const BinaryOperatorInfo kBinaryOperators[] = {
     // multiplicative
     {kOpMul, "*", kLogical | kRelational | kAdditive | kMultiplicative},
     {kOpDiv, "/", kLogical | kRelational | kAdditive | kMultiplicative},
     {kOpMod, "%", kLogical | kRelational | kAdditive | kMultiplicative},
     // additive
     {kOpAdd, "+", kLogical | kRelational | kAdditive | kMultiplicative},
     {kOpSub, "-", kLogical | kRelational | kAdditive | kMultiplicative},
     // bitwise
     {kOpBAnd, "&", kOpBAnd},
     {kOpBOr, "|", kOpBOr},
     {kOpBXor, "^", kOpBXor},
     // shift
     {kOpShl, "<<", kLogical | kRelational},
     {kOpShr, ">>", kLogical | kRelational},
     // relational
     {kOpLt, "<", kLogical | kShift | kAdditive | kMultiplicative},
     {kOpGt, ">", kLogical | kShift | kAdditive | kMultiplicative},
     {kOpLe, "<=", kLogical | kShift | kAdditive | kMultiplicative},
     {kOpGe, ">=", kLogical | kShift | kAdditive | kMultiplicative},
     {kOpEq, "==", kLogical | kShift | kAdditive | kMultiplicative},
     {kOpNe, "!=", kLogical | kShift | kAdditive | kMultiplicative},
     // logical
     {kOpLAnd, "&&", kOpLAnd | kRelational | kShift | kAdditive | kMultiplicative},
     {kOpLOr, "||", kOpLOr | kRelational | kShift | kAdditive | kMultiplicative},
 };

 struct Case {
     BinaryOperatorInfo lhs_op;
     BinaryOperatorInfo rhs_op;
     bool should_parse;
 };

 static bool ParsedAsTemplateArgumentList(BinaryOperatorInfo lhs_op, BinaryOperatorInfo rhs_op) {
     return lhs_op.bit == kOpLt && rhs_op.bit & (kOpGt | kOpGe | kOpShr);
 }
 static std::ostream& operator<<(std::ostream& o, const Case& c) {
     return o << "a " << c.lhs_op.symbol << " b " << c.rhs_op.symbol << " c ";
 }

 static std::vector<Case> Cases() {
     std::vector<Case> out;
     for (auto& lhs_op : kBinaryOperators) {
         for (auto& rhs_op : kBinaryOperators) {
             bool should_parse = (lhs_op.can_follow_without_paren & rhs_op.bit) &&
                                 !ParsedAsTemplateArgumentList(lhs_op, rhs_op);
             out.push_back({lhs_op, rhs_op, should_parse});
         }
     }
     return out;
 }

 using ParserImplMixedBinaryOpTest = ParserImplTestWithParam<Case>;

 TEST_P(ParserImplMixedBinaryOpTest, Test) {
     std::stringstream wgsl;
     wgsl << GetParam();
     auto p = parser(wgsl.str());
     auto e = p->expression();
     if (GetParam().should_parse) {
         ASSERT_TRUE(e.matched) << e.errored;
         EXPECT_TRUE(e->Is<ast::BinaryExpression>());
     } else {
         EXPECT_FALSE(e.matched);
         EXPECT_TRUE(e.errored);
         EXPECT_EQ(e.value, nullptr);
         EXPECT_TRUE(p->has_error());
         std::stringstream expected;
         if (ParsedAsTemplateArgumentList(GetParam().lhs_op, GetParam().rhs_op)) {
             expected << "1:3: '<' treated as the start of a template argument list, which is not "
                         "supported for user-declared types or functions. If you intended "
                         "less-than, wrap the expression in parentheses";
         } else {
             expected << "1:3: mixing '" << GetParam().lhs_op.symbol << "' and '"
                      << GetParam().rhs_op.symbol << "' requires parenthesis";
         }
         EXPECT_EQ(p->error(), expected.str());
     }
 }
 INSTANTIATE_TEST_SUITE_P(ParserImplMixedBinaryOpTest,
                          ParserImplMixedBinaryOpTest,
                          testing::ValuesIn(Cases()));

 }  // namespace mixing_binary_ops

 }  // namespace
 }  // namespace tint::reader::wgsl
	// Copyright 2022 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 "src/tint/reader/wgsl/parser_impl_test_helper.h"

	namespace tint::reader::wgsl {
	namespace {

	TEST_F(ParserImplTest, Expression_InvalidLHS) {
	auto p = parser("if (a) {} \|\| true");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	EXPECT_EQ(e.value, nullptr);
	}

	TEST_F(ParserImplTest, Expression_Or_Parses) {
	auto p = parser("a \|\| true");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	EXPECT_EQ(e->source.range.begin.line, 1u);
	EXPECT_EQ(e->source.range.begin.column, 3u);
	EXPECT_EQ(e->source.range.end.line, 1u);
	EXPECT_EQ(e->source.range.end.column, 5u);

	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	auto* rel = e->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);

	ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
	auto* ident = rel->lhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

	ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
	ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
	}

	TEST_F(ParserImplTest, Expression_Or_Parses_Multiple) {
	auto p = parser("a \|\| true \|\| b");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	// lhs: (a \|\| true)
	// rhs: b
	auto* rel = e->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);

	ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
	auto* ident = rel->rhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));

	ASSERT_TRUE(rel->lhs->Is<ast::BinaryExpression>());
	// lhs: a
	// rhs: true
	rel = rel->lhs->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op);

	ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
	ident = rel->lhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

	ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
	ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
	}

	TEST_F(ParserImplTest, Expression_Or_InvalidRHS) {
	auto p = parser("true \|\| if (a) {}");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(p->error(), "1:9: unable to parse right side of \|\| expression");
	}

	TEST_F(ParserImplTest, Expression_And_Parses) {
	auto p = parser("a && true");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	EXPECT_EQ(e->source.range.begin.line, 1u);
	EXPECT_EQ(e->source.range.begin.column, 3u);
	EXPECT_EQ(e->source.range.end.line, 1u);
	EXPECT_EQ(e->source.range.end.column, 5u);

	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	auto* rel = e->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op);

	ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
	auto* ident = rel->lhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

	ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
	ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
	}

	TEST_F(ParserImplTest, Expression_And_Parses_Multple) {
	auto p = parser("a && true && b");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	// lhs: (a && true)
	// rhs: b
	auto* rel = e->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op);

	ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
	auto* ident = rel->rhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));

	ASSERT_TRUE(rel->lhs->Is<ast::BinaryExpression>());
	// lhs: a
	// rhs: true
	rel = rel->lhs->As<ast::BinaryExpression>();
	ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
	ident = rel->lhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

	ASSERT_TRUE(rel->rhs->Is<ast::BoolLiteralExpression>());
	ASSERT_TRUE(rel->rhs->As<ast::BoolLiteralExpression>()->value);
	}

	TEST_F(ParserImplTest, Expression_And_InvalidRHS) {
	auto p = parser("true && if (a) {}");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(p->error(), "1:9: unable to parse right side of && expression");
	}

	TEST_F(ParserImplTest, Expression_Mixing_OrWithAnd) {
	auto p = parser("a && true \|\| b");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(p->error(), "1:3: mixing '&&' and '\|\|' requires parenthesis");
	}

	TEST_F(ParserImplTest, Expression_Mixing_AndWithOr) {
	auto p = parser("a \|\| true && b");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(p->error(), "1:3: mixing '\|\|' and '&&' requires parenthesis");
	}

	TEST_F(ParserImplTest, Expression_Bitwise) {
	auto p = parser("a & b");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	auto* rel = e->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kAnd, rel->op);

	ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
	auto* ident = rel->lhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

	ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
	ident = rel->rhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));
	}

	TEST_F(ParserImplTest, Expression_Relational) {
	auto p = parser("a <= b");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	auto* rel = e->As<ast::BinaryExpression>();
	EXPECT_EQ(ast::BinaryOp::kLessThanEqual, rel->op);

	ASSERT_TRUE(rel->lhs->Is<ast::IdentifierExpression>());
	auto* ident = rel->lhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("a"));

	ASSERT_TRUE(rel->rhs->Is<ast::IdentifierExpression>());
	ident = rel->rhs->As<ast::IdentifierExpression>();
	EXPECT_EQ(ident->symbol, p->builder().Symbols().Get("b"));
	}

	TEST_F(ParserImplTest, Expression_InvalidUnary) {
	auto p = parser("!if \|\| true");
	auto e = p->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: unable to parse right side of ! expression");
	}

	TEST_F(ParserImplTest, Expression_InvalidBitwise) {
	auto p = parser("a & if");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(p->error(), "1:5: unable to parse right side of & expression");
	}

	TEST_F(ParserImplTest, Expression_InvalidRelational) {
	auto p = parser("a <= if");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(p->error(), "1:6: unable to parse right side of <= expression");
	}

	TEST_F(ParserImplTest, Expression_Associativity) {
	auto p = parser("1 < 2 \|\| 2 < 3");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);
	}

	TEST_F(ParserImplTest, Expression_InvalidAssociativity) {
	auto p = parser("1 < 2 && 2 < 3 \|\| 3 < 4");
	auto e = p->expression();
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_TRUE(p->has_error());
	EXPECT_EQ(e.value, nullptr);
	EXPECT_EQ(p->error(), R"(1:7: mixing '&&' and '\|\|' requires parenthesis)");
	}

	TEST_F(ParserImplTest, Expression_SubtractionNoSpace) {
	auto p = parser("(2-1)");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);
	ASSERT_TRUE(e->Is<ast::BinaryExpression>());
	auto* b = e->As<ast::BinaryExpression>();
	EXPECT_TRUE(b->IsSubtract());

	ASSERT_TRUE(b->lhs->Is<ast::IntLiteralExpression>());
	ASSERT_TRUE(b->rhs->Is<ast::IntLiteralExpression>());

	EXPECT_EQ(b->lhs->As<ast::IntLiteralExpression>()->value, 2);
	EXPECT_EQ(b->rhs->As<ast::IntLiteralExpression>()->value, 1);
	}

	TEST_F(ParserImplTest, Expression_NegatedNumber) {
	auto p = parser("-1");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
	auto* b = e->As<ast::UnaryOpExpression>();
	EXPECT_EQ(b->op, ast::UnaryOp::kNegation);

	ASSERT_TRUE(b->expr->Is<ast::IntLiteralExpression>());
	EXPECT_EQ(b->expr->As<ast::IntLiteralExpression>()->value, 1);
	}

	TEST_F(ParserImplTest, Expression_MaxI32) {
	auto p = parser("2147483647");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::IntLiteralExpression>());
	EXPECT_EQ(e->As<ast::IntLiteralExpression>()->value, 2147483647);
	}

	TEST_F(ParserImplTest, Expression_MinI32) {
	auto p = parser("-2147483648");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
	auto* b = e->As<ast::UnaryOpExpression>();
	EXPECT_EQ(b->op, ast::UnaryOp::kNegation);

	ASSERT_TRUE(b->expr->Is<ast::IntLiteralExpression>());
	EXPECT_EQ(b->expr->As<ast::IntLiteralExpression>()->value, 2147483648);
	}

	TEST_F(ParserImplTest, Expression_MaxU32) {
	auto p = parser("4294967295");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::IntLiteralExpression>());
	EXPECT_EQ(e->As<ast::IntLiteralExpression>()->value, 4294967295);
	}

	TEST_F(ParserImplTest, Expression_MaxF32) {
	const auto highest = std::numeric_limits<float>::max();
	const auto expected_highest = 340282346638528859811704183484516925440.0f;
	if (highest < expected_highest \|\| highest > expected_highest) {
	GTEST_SKIP() << "std::numeric_limits<float>::max() is not as expected for "
	"this target";
	}

	auto p = parser("340282346638528859811704183484516925440.0f");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::FloatLiteralExpression>());
	EXPECT_EQ(e->As<ast::FloatLiteralExpression>()->value,
	340282346638528859811704183484516925440.0f);
	}

	TEST_F(ParserImplTest, Expression_MinF32) {
	const auto lowest = std::numeric_limits<float>::lowest();
	const auto expected_lowest = -340282346638528859811704183484516925440.0f;
	if (lowest < expected_lowest \|\| lowest > expected_lowest) {
	GTEST_SKIP() << "std::numeric_limits<float>::lowest() is not as expected for "
	"this target";
	}

	auto p = parser("-340282346638528859811704183484516925440.0f");
	auto e = p->expression();
	EXPECT_TRUE(e.matched);
	EXPECT_FALSE(e.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(e.value, nullptr);

	ASSERT_TRUE(e->Is<ast::UnaryOpExpression>());
	auto* b = e->As<ast::UnaryOpExpression>();
	EXPECT_EQ(b->op, ast::UnaryOp::kNegation);

	ASSERT_TRUE(b->expr->Is<ast::FloatLiteralExpression>());
	EXPECT_EQ(b->expr->As<ast::FloatLiteralExpression>()->value,
	340282346638528859811704183484516925440.0f);
	}

	namespace mixing_binary_ops {

	struct BinaryOperatorInfo {
	// A uint64_t with a single bit assigned that uniquely identifies the binary-op.
	uint64_t bit;
	// The WGSL operator symbol. Example: '<='
	const char* symbol;
	// A bit mask of all operators that can immediately follow the RHS of this operator without
	// requiring parentheses. In other words, `can_follow_without_paren` is the full set of
	// operators that can substitute `<next-operator>` in the WGSL:
	// `expr_a <this-operator> expr_b <next-operator> expr_c`
	// without requiring additional parentheses.
	uint64_t can_follow_without_paren;
	};

	// Each binary operator is given a unique bit in a uint64_t
	static constexpr uint64_t kOpMul = static_cast<uint64_t>(1) << 0;
	static constexpr uint64_t kOpDiv = static_cast<uint64_t>(1) << 1;
	static constexpr uint64_t kOpMod = static_cast<uint64_t>(1) << 2;
	static constexpr uint64_t kOpAdd = static_cast<uint64_t>(1) << 3;
	static constexpr uint64_t kOpSub = static_cast<uint64_t>(1) << 4;
	static constexpr uint64_t kOpBAnd = static_cast<uint64_t>(1) << 5;
	static constexpr uint64_t kOpBOr = static_cast<uint64_t>(1) << 6;
	static constexpr uint64_t kOpBXor = static_cast<uint64_t>(1) << 7;
	static constexpr uint64_t kOpShl = static_cast<uint64_t>(1) << 8;
	static constexpr uint64_t kOpShr = static_cast<uint64_t>(1) << 9;
	static constexpr uint64_t kOpLt = static_cast<uint64_t>(1) << 10;
	static constexpr uint64_t kOpGt = static_cast<uint64_t>(1) << 11;
	static constexpr uint64_t kOpLe = static_cast<uint64_t>(1) << 12;
	static constexpr uint64_t kOpGe = static_cast<uint64_t>(1) << 13;
	static constexpr uint64_t kOpEq = static_cast<uint64_t>(1) << 14;
	static constexpr uint64_t kOpNe = static_cast<uint64_t>(1) << 15;
	static constexpr uint64_t kOpLAnd = static_cast<uint64_t>(1) << 16;
	static constexpr uint64_t kOpLOr = static_cast<uint64_t>(1) << 17;

	// Bit mask for the binary operator groups
	static constexpr uint64_t kMultiplicative = kOpMul \| kOpDiv \| kOpMod;
	static constexpr uint64_t kAdditive = kOpAdd \| kOpSub;
	static constexpr uint64_t kShift = kOpShl \| kOpShr;
	static constexpr uint64_t kRelational = kOpLt \| kOpGt \| kOpLe \| kOpGe \| kOpEq \| kOpNe;
	static constexpr uint64_t kLogical = kOpLAnd \| kOpLOr;

	// The binary operator table
	static constexpr const BinaryOperatorInfo kBinaryOperators[] = {
	// multiplicative
	{kOpMul, "*", kLogical \| kRelational \| kAdditive \| kMultiplicative},
	{kOpDiv, "/", kLogical \| kRelational \| kAdditive \| kMultiplicative},
	{kOpMod, "%", kLogical \| kRelational \| kAdditive \| kMultiplicative},
	// additive
	{kOpAdd, "+", kLogical \| kRelational \| kAdditive \| kMultiplicative},
	{kOpSub, "-", kLogical \| kRelational \| kAdditive \| kMultiplicative},
	// bitwise
	{kOpBAnd, "&", kOpBAnd},
	{kOpBOr, "\|", kOpBOr},
	{kOpBXor, "^", kOpBXor},
	// shift
	{kOpShl, "<<", kLogical \| kRelational},
	{kOpShr, ">>", kLogical \| kRelational},
	// relational
	{kOpLt, "<", kLogical \| kShift \| kAdditive \| kMultiplicative},
	{kOpGt, ">", kLogical \| kShift \| kAdditive \| kMultiplicative},
	{kOpLe, "<=", kLogical \| kShift \| kAdditive \| kMultiplicative},
	{kOpGe, ">=", kLogical \| kShift \| kAdditive \| kMultiplicative},
	{kOpEq, "==", kLogical \| kShift \| kAdditive \| kMultiplicative},
	{kOpNe, "!=", kLogical \| kShift \| kAdditive \| kMultiplicative},
	// logical
	{kOpLAnd, "&&", kOpLAnd \| kRelational \| kShift \| kAdditive \| kMultiplicative},
	{kOpLOr, "\|\|", kOpLOr \| kRelational \| kShift \| kAdditive \| kMultiplicative},
	};

	struct Case {
	BinaryOperatorInfo lhs_op;
	BinaryOperatorInfo rhs_op;
	bool should_parse;
	};

	static bool ParsedAsTemplateArgumentList(BinaryOperatorInfo lhs_op, BinaryOperatorInfo rhs_op) {
	return lhs_op.bit == kOpLt && rhs_op.bit & (kOpGt \| kOpGe \| kOpShr);
	}
	static std::ostream& operator<<(std::ostream& o, const Case& c) {
	return o << "a " << c.lhs_op.symbol << " b " << c.rhs_op.symbol << " c ";
	}

	static std::vector<Case> Cases() {
	std::vector<Case> out;
	for (auto& lhs_op : kBinaryOperators) {
	for (auto& rhs_op : kBinaryOperators) {
	bool should_parse = (lhs_op.can_follow_without_paren & rhs_op.bit) &&
	!ParsedAsTemplateArgumentList(lhs_op, rhs_op);
	out.push_back({lhs_op, rhs_op, should_parse});
	}
	}
	return out;
	}

	using ParserImplMixedBinaryOpTest = ParserImplTestWithParam<Case>;

	TEST_P(ParserImplMixedBinaryOpTest, Test) {
	std::stringstream wgsl;
	wgsl << GetParam();
	auto p = parser(wgsl.str());
	auto e = p->expression();
	if (GetParam().should_parse) {
	ASSERT_TRUE(e.matched) << e.errored;
	EXPECT_TRUE(e->Is<ast::BinaryExpression>());
	} else {
	EXPECT_FALSE(e.matched);
	EXPECT_TRUE(e.errored);
	EXPECT_EQ(e.value, nullptr);
	EXPECT_TRUE(p->has_error());
	std::stringstream expected;
	if (ParsedAsTemplateArgumentList(GetParam().lhs_op, GetParam().rhs_op)) {
	expected << "1:3: '<' treated as the start of a template argument list, which is not "
	"supported for user-declared types or functions. If you intended "
	"less-than, wrap the expression in parentheses";
	} else {
	expected << "1:3: mixing '" << GetParam().lhs_op.symbol << "' and '"
	<< GetParam().rhs_op.symbol << "' requires parenthesis";
	}
	EXPECT_EQ(p->error(), expected.str());
	}
	}
	INSTANTIATE_TEST_SUITE_P(ParserImplMixedBinaryOpTest,
	ParserImplMixedBinaryOpTest,
	testing::ValuesIn(Cases()));

	} // namespace mixing_binary_ops

	} // namespace
	} // namespace tint::reader::wgsl