diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator_test.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator_test.cc index 08d94e8472..8e00197f05 100644 --- a/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator_test.cc +++ b/src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator_test.cc @@ -203,7 +203,7 @@ TEST(ChangeUnaryOperatorTest, Signed_Integer_Types_Applicable2) { ASSERT_TRUE(result.success) << result.error; std::string expected_shader = R"(fn main() { - let b : vec3 = vec3(1, 3, -1); + let b : vec3 = vec3(1, 3, -(1)); var comp_b : vec3 = -(b); } )"; @@ -246,7 +246,7 @@ TEST(ChangeUnaryOperatorTest, Signed_Integer_Types_Applicable3) { ASSERT_TRUE(result.success) << result.error; std::string expected_shader = R"(fn main() { - var a = -5; + var a = -(5); var neg_a = ~(a); } )"; @@ -288,7 +288,7 @@ TEST(ChangeUnaryOperatorTest, Signed_Integer_Types_Applicable4) { ASSERT_TRUE(result.success) << result.error; std::string expected_shader = R"(fn main() { - var b : vec3 = vec3(1, 3, -1); + var b : vec3 = vec3(1, 3, -(1)); let neg_b : vec3 = ~(b); } )"; diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator_test.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator_test.cc index 4da9bf71ea..c73c1b3a5e 100644 --- a/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator_test.cc +++ b/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator_test.cc @@ -260,7 +260,7 @@ TEST(WrapUnaryOperatorTest, Applicable6) { ASSERT_TRUE(result.success) << result.error; std::string expected_shader = R"(fn main() { - var a : vec4 = -(vec4(-1.0, -1.0, -1.0, -1.0)); + var a : vec4 = -(vec4(-(1.0), -(1.0), -(1.0), -(1.0))); } )"; ASSERT_EQ(expected_shader, result.wgsl); @@ -345,7 +345,7 @@ TEST(WrapUnaryOperatorTest, Applicable8) { ASSERT_TRUE(result.success) << result.error; std::string expected_shader = R"(fn main() { - var a : vec4 = ~(vec4(1, 0, -1, 0)); + var a : vec4 = ~(vec4(1, 0, -(1), 0)); } )"; ASSERT_EQ(expected_shader, result.wgsl); diff --git a/src/tint/reader/wgsl/lexer.cc b/src/tint/reader/wgsl/lexer.cc index 0bc19ad132..16712cae40 100644 --- a/src/tint/reader/wgsl/lexer.cc +++ b/src/tint/reader/wgsl/lexer.cc @@ -328,9 +328,6 @@ Token Lexer::try_float() { auto source = begin_source(); bool has_mantissa_digits = false; - if (matches(end, '-')) { - end++; - } while (end < length() && is_digit(at(end))) { has_mantissa_digits = true; end++; @@ -426,7 +423,6 @@ Token Lexer::try_hex_float() { constexpr uint64_t kExponentMask = (1 << kExponentBits) - 1; constexpr int64_t kExponentMax = kExponentMask; // Including NaN / inf constexpr uint64_t kExponentLeftShift = kMantissaBits; - constexpr uint64_t kSignBit = kTotalBits - 1; constexpr uint64_t kOne = 1; auto start = pos(); @@ -434,16 +430,8 @@ Token Lexer::try_hex_float() { auto source = begin_source(); - // clang-format off - // -?0[xX]([0-9a-fA-F]*.?[0-9a-fA-F]+ | [0-9a-fA-F]+.[0-9a-fA-F]*)(p|P)(+|-)?[0-9]+ // NOLINT - // clang-format on + // 0[xX]([0-9a-fA-F]*.?[0-9a-fA-F]+ | [0-9a-fA-F]+.[0-9a-fA-F]*)(p|P)(+|-)?[0-9]+ // NOLINT - // -? - uint64_t sign_bit = 0; - if (matches(end, '-')) { - sign_bit = 1; - end++; - } // 0[xX] if (matches(end, '0') && (matches(end + 1, 'x') || matches(end + 1, 'X'))) { end += 2; @@ -696,7 +684,7 @@ Token Lexer::try_hex_float() { } // Combine sign, mantissa, and exponent - uint64_t result_u64 = sign_bit << kSignBit; + uint64_t result_u64 = 0; result_u64 |= mantissa; result_u64 |= (static_cast(signed_exponent) & kExponentMask) << kExponentLeftShift; @@ -856,10 +844,6 @@ Token Lexer::try_hex_integer() { auto source = begin_source(); - if (matches(curr, '-')) { - curr++; - } - if (matches(curr, '0') && (matches(curr + 1, 'x') || matches(curr + 1, 'X'))) { curr += 2; } else { @@ -880,10 +864,6 @@ Token Lexer::try_integer() { auto source = begin_source(); - if (matches(curr, '-')) { - curr++; - } - if (curr >= length() || !is_digit(at(curr))) { return {}; } diff --git a/src/tint/reader/wgsl/lexer_test.cc b/src/tint/reader/wgsl/lexer_test.cc index 3268eaf836..a7c13e6d72 100644 --- a/src/tint/reader/wgsl/lexer_test.cc +++ b/src/tint/reader/wgsl/lexer_test.cc @@ -426,57 +426,35 @@ INSTANTIATE_TEST_SUITE_P(LexerTest, // No decimal, with 'f' suffix FloatData{"0f", 0.0}, FloatData{"1f", 1.0}, - FloatData{"-0f", 0.0}, - FloatData{"-1f", -1.0}, // No decimal, with 'h' suffix FloatData{"0h", 0.0}, FloatData{"1h", 1.0}, - FloatData{"-0h", 0.0}, - FloatData{"-1h", -1.0}, // Zero, with decimal. FloatData{"0.0", 0.0}, FloatData{"0.", 0.0}, FloatData{".0", 0.0}, - FloatData{"-0.0", 0.0}, - FloatData{"-0.", 0.0}, - FloatData{"-.0", 0.0}, // Zero, with decimal and 'f' suffix FloatData{"0.0f", 0.0}, FloatData{"0.f", 0.0}, FloatData{".0f", 0.0}, - FloatData{"-0.0f", 0.0}, - FloatData{"-0.f", 0.0}, - FloatData{"-.0f", 0.0}, // Zero, with decimal and 'h' suffix FloatData{"0.0h", 0.0}, FloatData{"0.h", 0.0}, FloatData{".0h", 0.0}, - FloatData{"-0.0h", 0.0}, - FloatData{"-0.h", 0.0}, - FloatData{"-.0h", 0.0}, // Non-zero with decimal FloatData{"5.7", 5.7}, FloatData{"5.", 5.}, FloatData{".7", .7}, - FloatData{"-5.7", -5.7}, - FloatData{"-5.", -5.}, - FloatData{"-.7", -.7}, // Non-zero with decimal and 'f' suffix FloatData{"5.7f", static_cast(5.7f)}, FloatData{"5.f", static_cast(5.f)}, FloatData{".7f", static_cast(.7f)}, - FloatData{"-5.7f", static_cast(-5.7f)}, - FloatData{"-5.f", static_cast(-5.f)}, - FloatData{"-.7f", static_cast(-.7f)}, // Non-zero with decimal and 'h' suffix FloatData{"5.7h", static_cast(f16::Quantize(5.7f))}, FloatData{"5.h", static_cast(f16::Quantize(5.f))}, FloatData{".7h", static_cast(f16::Quantize(.7f))}, - FloatData{"-5.7h", static_cast(f16::Quantize(-5.7f))}, - FloatData{"-5.h", static_cast(f16::Quantize(-5.f))}, - FloatData{"-.7h", static_cast(f16::Quantize(-.7f))}, // No decimal, with exponent FloatData{"1e5", 1e5}, @@ -532,7 +510,6 @@ TEST_P(FloatTest_Invalid, Handles) { INSTANTIATE_TEST_SUITE_P(LexerTest, FloatTest_Invalid, testing::Values(".", - "-.", // Need a mantissa digit ".e5", ".E5", @@ -545,9 +522,7 @@ INSTANTIATE_TEST_SUITE_P(LexerTest, ".e-", // Overflow "2.5e+256f", - "-2.5e+127f", "6.5520e+4h", - "-6.5e+12h", // Decimal exponent must immediately // follow the 'e'. "2.5e 12", @@ -791,12 +766,9 @@ INSTANTIATE_TEST_SUITE_P(Dec_AInt, testing::Combine(testing::Values('\0'), // No suffix testing::ValuesIn(std::vector{ {"0", 0}, - {"-2", -2}, {"2", 2}, {"123", 123}, {"2147483647", 2147483647}, - {"-2147483648", -2147483648LL}, - {"-9223372036854775808", -9223372036854775807LL - 1}, }))); INSTANTIATE_TEST_SUITE_P(Dec_u32, @@ -813,11 +785,8 @@ INSTANTIATE_TEST_SUITE_P(Dec_i32, testing::Combine(testing::Values('i'), // Suffix testing::ValuesIn(std::vector{ {"0i", 0u}, - {"-0i", 0u}, {"123i", 123}, - {"-123i", -123}, {"2147483647i", 2147483647}, - {"-2147483647i", -2147483647ll}, }))); INSTANTIATE_TEST_SUITE_P(Hex_AInt, @@ -828,16 +797,10 @@ INSTANTIATE_TEST_SUITE_P(Hex_AInt, {"0X0", 0}, {"0x42", 66}, {"0X42", 66}, - {"-0x42", -66}, - {"-0X42", -66}, {"0xeF1Abc9", 0xeF1Abc9}, {"0XeF1Abc9", 0xeF1Abc9}, - {"-0xeF1Abc9", -0xeF1Abc9}, - {"-0XeF1Abc9", -0xeF1Abc9}, {"0x80000000", 0x80000000}, {"0X80000000", 0X80000000}, - {"-0x80000000", -0x80000000ll}, - {"-0X80000000", -0X80000000ll}, {"0x7FFFFFFF", 0x7fffffff}, {"0X7FFFFFFF", 0x7fffffff}, {"0x7fffffff", 0x7fffffff}, @@ -845,7 +808,6 @@ INSTANTIATE_TEST_SUITE_P(Hex_AInt, {"0x7FfFfFfF", 0x7fffffff}, {"0X7FfFfFfF", 0x7fffffff}, {"0x7fffffffffffffff", 0x7fffffffffffffffll}, - {"-0x7fffffffffffffff", -0x7fffffffffffffffll}, }))); INSTANTIATE_TEST_SUITE_P(Hex_u32, @@ -869,22 +831,13 @@ INSTANTIATE_TEST_SUITE_P(Hex_i32, testing::ValuesIn(std::vector{ {"0x0i", 0}, {"0x42i", 66}, - {"-0x0i", 0}, - {"-0x42i", -66}, {"0xeF1Abc9i", 250719177}, - {"-0xeF1Abc9i", -250719177}, {"0x7FFFFFFFi", 0x7fffffff}, - {"-0x7FFFFFFFi", -0x7fffffff}, {"0X7FFFFFFFi", 0x7fffffff}, - {"-0X7FFFFFFFi", -0x7fffffff}, {"0x7fffffffi", 0x7fffffff}, - {"-0x7fffffffi", -0x7fffffff}, {"0X7fffffffi", 0x7fffffff}, - {"-0X7fffffffi", -0x7fffffff}, {"0x7FfFfFfFi", 0x7fffffff}, - {"-0x7FfFfFfFi", -0x7fffffff}, {"0X7FfFfFfFi", 0x7fffffff}, - {"-0X7FfFfFfFi", -0x7fffffff}, }))); //////////////////////////////////////////////////////////////////////////////// // ParseIntegerTest_CannotBeRepresented @@ -920,9 +873,8 @@ INSTANTIATE_TEST_SUITE_P(i32, INSTANTIATE_TEST_SUITE_P(u32, ParseIntegerTest_CannotBeRepresented, - testing::Combine(testing::Values("u32"), // type - testing::Values("4294967296u", // - "-1u"))); + testing::Combine(testing::Values("u32"), // type + testing::Values("4294967296u"))); //////////////////////////////////////////////////////////////////////////////// // ParseIntegerTest_LeadingZeros @@ -942,7 +894,7 @@ TEST_P(ParseIntegerTest_LeadingZeros, Parse) { INSTANTIATE_TEST_SUITE_P(LeadingZero, ParseIntegerTest_LeadingZeros, - testing::Values("01234", "0000", "-00", "00u")); + testing::Values("01234", "0000", "00u")); //////////////////////////////////////////////////////////////////////////////// // ParseIntegerTest_NoSignificantDigits @@ -962,18 +914,7 @@ TEST_P(ParseIntegerTest_NoSignificantDigits, Parse) { INSTANTIATE_TEST_SUITE_P(LeadingZero, ParseIntegerTest_NoSignificantDigits, - testing::Values("0x", - "0X", - "-0x", - "-0X", - "0xu", - "0Xu", - "-0xu", - "-0Xu", - "0xi", - "0Xi", - "-0xi", - "-0Xi")); + testing::Values("0x", "0X", "0xu", "0Xu", "0xi", "0Xi")); struct TokenData { const char* input; diff --git a/src/tint/reader/wgsl/parser_impl_argument_expression_list_test.cc b/src/tint/reader/wgsl/parser_impl_argument_expression_list_test.cc index 7f1132ced7..e22a7060ab 100644 --- a/src/tint/reader/wgsl/parser_impl_argument_expression_list_test.cc +++ b/src/tint/reader/wgsl/parser_impl_argument_expression_list_test.cc @@ -37,7 +37,7 @@ TEST_F(ParserImplTest, ArgumentExpressionList_ParsesEmptyList) { } TEST_F(ParserImplTest, ArgumentExpressionList_ParsesMultiple) { - auto p = parser("(a, -33, 1+2)"); + auto p = parser("(a, 33, 1+2)"); auto e = p->expect_argument_expression_list("argument list"); ASSERT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(e.errored); diff --git a/src/tint/reader/wgsl/parser_impl_const_literal_test.cc b/src/tint/reader/wgsl/parser_impl_const_literal_test.cc index 16861e407e..af7b38e14f 100644 --- a/src/tint/reader/wgsl/parser_impl_const_literal_test.cc +++ b/src/tint/reader/wgsl/parser_impl_const_literal_test.cc @@ -67,32 +67,6 @@ TEST_F(ParserImplTest, ConstLiteral_Int) { ast::IntLiteralExpression::Suffix::kI); EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 5u}})); } - { - auto p = parser("-234"); - auto c = p->const_literal(); - EXPECT_TRUE(c.matched); - EXPECT_FALSE(c.errored); - EXPECT_FALSE(p->has_error()) << p->error(); - ASSERT_NE(c.value, nullptr); - ASSERT_TRUE(c->Is()); - EXPECT_EQ(c->As()->value, -234); - EXPECT_EQ(c->As()->suffix, - ast::IntLiteralExpression::Suffix::kNone); - EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 5u}})); - } - { - auto p = parser("-234i"); - auto c = p->const_literal(); - EXPECT_TRUE(c.matched); - EXPECT_FALSE(c.errored); - EXPECT_FALSE(p->has_error()) << p->error(); - ASSERT_NE(c.value, nullptr); - ASSERT_TRUE(c->Is()); - EXPECT_EQ(c->As()->value, -234); - EXPECT_EQ(c->As()->suffix, - ast::IntLiteralExpression::Suffix::kI); - EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 6u}})); - } } TEST_F(ParserImplTest, ConstLiteral_Uint) { @@ -108,15 +82,6 @@ TEST_F(ParserImplTest, ConstLiteral_Uint) { EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 5u}})); } -TEST_F(ParserImplTest, ConstLiteral_Uint_Negative) { - auto p = parser("-234u"); - auto c = p->const_literal(); - EXPECT_FALSE(c.matched); - EXPECT_TRUE(c.errored); - EXPECT_EQ(p->error(), "1:1: value cannot be represented as 'u32'"); - ASSERT_EQ(c.value, nullptr); -} - TEST_F(ParserImplTest, ConstLiteral_InvalidFloat_IncompleteExponent) { auto p = parser("1.0e+"); auto c = p->const_literal(); @@ -174,15 +139,11 @@ using FloatLiteralTestCaseList = std::vector; INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_Float, ParserImplFloatLiteralTest, testing::ValuesIn(FloatLiteralTestCaseList{ - {"0.0", 0.0}, // Zero - {"1.0", 1.0}, // One - {"-1.0", -1.0}, // MinusOne - {"1000000000.0", 1e9}, // Billion - {"-0.0", std::copysign(0.0, -5.0)}, // NegativeZero - {"0.0", MakeDouble(0, 0, 0)}, // Zero - {"-0.0", MakeDouble(1, 0, 0)}, // NegativeZero - {"1.0", MakeDouble(0, 1023, 0)}, // One - {"-1.0", MakeDouble(1, 1023, 0)}, // NegativeOne + {"0.0", 0.0}, // Zero + {"1.0", 1.0}, // One + {"1000000000.0", 1e9}, // Billion + {"0.0", MakeDouble(0, 0, 0)}, // Zero + {"1.0", MakeDouble(0, 1023, 0)}, // One {"234.e12", 234.e12}, {"234.e12f", static_cast(234.e12f)}, @@ -190,47 +151,29 @@ INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_Float, // Tiny cases {"1e-5000", 0.0}, - {"-1e-5000", 0.0}, {"1e-5000f", 0.0}, - {"-1e-5000f", 0.0}, {"1e-50f", 0.0}, - {"-1e-50f", 0.0}, {"1e-5000h", 0.0}, - {"-1e-5000h", 0.0}, {"1e-50h", 0.0}, - {"-1e-50h", 0.0}, {"1e-8h", 0.0}, // The smallest positive subnormal f16 is 5.96e-8 - {"-1e-8h", 0.0}, // Nearly overflow {"1.e308", 1.e308}, - {"-1.e308", -1.e308}, {"1.8e307", 1.8e307}, - {"-1.8e307", -1.8e307}, {"1.798e307", 1.798e307}, - {"-1.798e307", -1.798e307}, {"1.7977e307", 1.7977e307}, - {"-1.7977e307", -1.7977e307}, // Nearly overflow {"1e38f", static_cast(1e38f)}, - {"-1e38f", static_cast(-1e38f)}, {"4.0e37f", static_cast(4.0e37f)}, - {"-4.0e37f", static_cast(-4.0e37f)}, {"3.5e37f", static_cast(3.5e37f)}, - {"-3.5e37f", static_cast(-3.5e37f)}, {"3.403e37f", static_cast(3.403e37f)}, - {"-3.403e37f", static_cast(-3.403e37f)}, // Nearly overflow {"6e4h", 6e4}, - {"-6e4h", -6e4}, {"8.0e3h", 8.0e3}, - {"-8.0e3h", -8.0e3}, {"3.5e3h", 3.5e3}, - {"-3.5e3h", -3.5e3}, - {"3.403e3h", 3.402e3}, // Quantized - {"-3.403e3h", -3.402e3}, // Quantized + {"3.403e3h", 3.402e3}, // Quantized })); const double NegInf = MakeDouble(1, 0x7FF, 0); @@ -246,11 +189,6 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x1p-1", 0x1p-1}, {"0x1p-2", 0x1p-2}, {"0x1.8p-1", 0x1.8p-1}, - {"-0x0p+0", -0x0p+0}, - {"-0x1p+0", -0x1p+0}, - {"-0x1p-1", -0x1p-1}, - {"-0x1p-2", -0x1p-2}, - {"-0x1.8p-1", -0x1.8p-1}, {"0x0.4p+1", 0x0.4p+1}, {"0x0.02p+3", 0x0.02p+3}, {"0x4.4p+1", 0x4.4p+1}, @@ -260,43 +198,28 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x1p+9", 0x1p+9}, {"0x1p+10", 0x1p+10}, {"0x1.02p+10", 0x1.02p+10}, - {"-0x1p+9", -0x1p+9}, - {"-0x1p+10", -0x1p+10}, - {"-0x1.02p+10", -0x1.02p+10}, // Small numbers {"0x1p-9", 0x1p-9}, {"0x1p-10", 0x1p-10}, {"0x1.02p-3", 0x1.02p-3}, - {"-0x1p-9", -0x1p-9}, - {"-0x1p-10", -0x1p-10}, - {"-0x1.02p-3", -0x1.02p-3}, // Near lowest non-denorm {"0x1p-1020", 0x1p-1020}, {"0x1p-1021", 0x1p-1021}, - {"-0x1p-1020", -0x1p-1020}, - {"-0x1p-1021", -0x1p-1021}, {"0x1p-124f", 0x1p-124}, {"0x1p-125f", 0x1p-125}, - {"-0x1p-124f", -0x1p-124}, - {"-0x1p-125f", -0x1p-125}, {"0x1p-12h", 0x1p-12}, {"0x1p-13h", 0x1p-13}, - {"-0x1p-12h", -0x1p-12}, - {"-0x1p-13h", -0x1p-13}, // Lowest non-denorm {"0x1p-1022", 0x1p-1022}, - {"-0x1p-1022", -0x1p-1022}, {"0x1p-126f", 0x1p-126}, - {"-0x1p-126f", -0x1p-126}, {"0x1p-14h", 0x1p-14}, - {"-0x1p-14h", -0x1p-14}, // Denormalized values {"0x1p-1023", 0x1p-1023}, @@ -305,10 +228,6 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x0.2p-1021", 0x0.2p-1021}, {"0x1p-1025", 0x1p-1025}, {"0x1p-1026", 0x1p-1026}, - {"-0x1p-1023", -0x1p-1023}, - {"-0x1p-1024", -0x1p-1024}, - {"-0x1p-1025", -0x1p-1025}, - {"-0x1p-1026", -0x1p-1026}, {"0x1.8p-1023", 0x1.8p-1023}, {"0x1.8p-1024", 0x1.8p-1024}, @@ -318,10 +237,6 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x0.2p-125f", 0x0.2p-125}, {"0x1p-129f", 0x1p-129}, {"0x1p-130f", 0x1p-130}, - {"-0x1p-127f", -0x1p-127}, - {"-0x1p-128f", -0x1p-128}, - {"-0x1p-129f", -0x1p-129}, - {"-0x1p-130f", -0x1p-130}, {"0x1.8p-127f", 0x1.8p-127}, {"0x1.8p-128f", 0x1.8p-128}, @@ -331,52 +246,31 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x0.2p-13h", 0x0.2p-13}, {"0x1p-17h", 0x1p-17}, {"0x1p-18h", 0x1p-18}, - {"-0x1p-15h", -0x1p-15}, - {"-0x1p-16h", -0x1p-16}, - {"-0x1p-17h", -0x1p-17}, - {"-0x1p-18h", -0x1p-18}, {"0x1.8p-15h", 0x1.8p-15}, {"0x1.8p-16h", 0x1.8p-16}, // F64 extremities - {"0x1p-1074", 0x1p-1074}, // +SmallestDenormal - {"0x1p-1073", 0x1p-1073}, // +BiggerDenormal - {"0x1.ffffffffffffep-1023", 0x1.ffffffffffffep-1023}, // +LargestDenormal - {"0x0.fffffffffffffp-1022", 0x0.fffffffffffffp-1022}, // +LargestDenormal - {"-0x1p-1074", -0x1p-1074}, // -SmallestDenormal - {"-0x1p-1073", -0x1p-1073}, // -BiggerDenormal - {"-0x1.ffffffffffffep-1023", -0x1.ffffffffffffep-1023}, // -LargestDenormal - {"-0x0.fffffffffffffp-1022", -0x0.fffffffffffffp-1022}, // -LargestDenormal + {"0x1p-1074", 0x1p-1074}, // +SmallestDenormal + {"0x1p-1073", 0x1p-1073}, // +BiggerDenormal + {"0x1.ffffffffffffep-1023", 0x1.ffffffffffffep-1023}, // +LargestDenormal + {"0x0.fffffffffffffp-1022", 0x0.fffffffffffffp-1022}, // +LargestDenormal - {"0x0.cafebeeff000dp-1022", 0x0.cafebeeff000dp-1022}, // +Subnormal - {"-0x0.cafebeeff000dp-1022", -0x0.cafebeeff000dp-1022}, // -Subnormal - {"0x1.2bfaf8p-1052", 0x1.2bfaf8p-1052}, // +Subnormal - {"-0x1.2bfaf8p-1052", -0x1.2bfaf8p-1052}, // +Subnormal - {"0x1.55554p-1055", 0x1.55554p-1055}, // +Subnormal - {"-0x1.55554p-1055", -0x1.55554p-1055}, // -Subnormal + {"0x0.cafebeeff000dp-1022", 0x0.cafebeeff000dp-1022}, // +Subnormal + {"0x1.2bfaf8p-1052", 0x1.2bfaf8p-1052}, // +Subnormal + {"0x1.55554p-1055", 0x1.55554p-1055}, // +Subnormal {"0x1.fffffffffffp-1027", 0x1.fffffffffffp-1027}, // +Subnormal, = 0x0.0fffffffffff8p-1022 - {"-0x1.fffffffffffp-1027", -0x1.fffffffffffp-1027}, // -Subnormal // F32 extremities - {"0x1p-149f", 0x1p-149}, // +SmallestDenormal - {"0x1p-148f", 0x1p-148}, // +BiggerDenormal - {"0x1.fffffcp-127f", 0x1.fffffcp-127}, // +LargestDenormal - {"0x0.fffffep-126f", 0x0.fffffep-126}, // +LargestDenormal - {"0x1.0p-126f", 0x1.0p-126}, // +SmallestNormal - {"0x8.0p-129f", 0x8.0p-129}, // +SmallestNormal - {"-0x1p-149f", -0x1p-149}, // -SmallestDenormal - {"-0x1p-148f", -0x1p-148}, // -BiggerDenormal - {"-0x1.fffffcp-127f", -0x1.fffffcp-127}, // -LargestDenormal - {"-0x0.fffffep-126f", -0x0.fffffep-126}, // -LargestDenormal - {"-0x1.0p-126f", -0x1.0p-126}, // -SmallestNormal - {"-0x8.0p-129f", -0x8.0p-129}, // -SmallestNormal + {"0x1p-149f", 0x1p-149}, // +SmallestDenormal + {"0x1p-148f", 0x1p-148}, // +BiggerDenormal + {"0x1.fffffcp-127f", 0x1.fffffcp-127}, // +LargestDenormal + {"0x0.fffffep-126f", 0x0.fffffep-126}, // +LargestDenormal + {"0x1.0p-126f", 0x1.0p-126}, // +SmallestNormal + {"0x8.0p-129f", 0x8.0p-129}, // +SmallestNormal - {"0x0.cafebp-129f", 0x0.cafebp-129}, // +Subnormal - {"-0x0.cafebp-129f", -0x0.cafebp-129}, // -Subnormal - {"0x1.2bfaf8p-127f", 0x1.2bfaf8p-127}, // +Subnormal - {"-0x1.2bfaf8p-127f", -0x1.2bfaf8p-127}, // -Subnormal - {"0x1.55554p-130f", 0x1.55554p-130}, // +Subnormal - {"-0x1.55554p-130f", -0x1.55554p-130}, // -Subnormal + {"0x0.cafebp-129f", 0x0.cafebp-129}, // +Subnormal + {"0x1.2bfaf8p-127f", 0x1.2bfaf8p-127}, // +Subnormal + {"0x1.55554p-130f", 0x1.55554p-130}, // +Subnormal // F32 exactly representable {"0x1.000002p+0f", 0x1.000002p+0}, @@ -385,31 +279,20 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x8.00003p+0f", 0x8.00003p+0}, {"0x2.123p+0f", 0x2.123p+0}, {"0x2.cafefp+0f", 0x2.cafefp+0}, - {"0x0.0000fep-126f", 0x0.0000fep-126}, // Subnormal - {"-0x0.0000fep-126f", -0x0.0000fep-126}, // Subnormal - {"0x3.f8p-144f", 0x3.f8p-144}, // Subnormal - {"-0x3.f8p-144f", -0x3.f8p-144}, // Subnormal + {"0x0.0000fep-126f", 0x0.0000fep-126}, // Subnormal + {"0x3.f8p-144f", 0x3.f8p-144}, // Subnormal // F16 extremities - {"0x1p-24h", 0x1p-24}, // +SmallestDenormal - {"0x1p-23h", 0x1p-23}, // +BiggerDenormal - {"0x1.ff8p-15h", 0x1.ff8p-15}, // +LargestDenormal - {"0x0.ffcp-14h", 0x0.ffcp-14}, // +LargestDenormal - {"0x1.0p-14h", 0x1.0p-14}, // +SmallestNormal - {"0x8.0p-17h", 0x8.0p-17}, // +SmallestNormal - {"-0x1p-24h", -0x1p-24}, // -SmallestDenormal - {"-0x1p-23h", -0x1p-23}, // -BiggerDenormal - {"-0x1.ff8p-15h", -0x1.ff8p-15}, // -LargestDenormal - {"-0x0.ffcp-14h", -0x0.ffcp-14}, // -LargestDenormal - {"-0x1.0p-14h", -0x1.0p-14}, // -SmallestNormal - {"-0x8.0p-17h", -0x8.0p-17}, // -SmallestNormal + {"0x1p-24h", 0x1p-24}, // +SmallestDenormal + {"0x1p-23h", 0x1p-23}, // +BiggerDenormal + {"0x1.ff8p-15h", 0x1.ff8p-15}, // +LargestDenormal + {"0x0.ffcp-14h", 0x0.ffcp-14}, // +LargestDenormal + {"0x1.0p-14h", 0x1.0p-14}, // +SmallestNormal + {"0x8.0p-17h", 0x8.0p-17}, // +SmallestNormal - {"0x0.a8p-19h", 0x0.a8p-19}, // +Subnormal - {"-0x0.a8p-19h", -0x0.a8p-19}, // -Subnormal - {"0x1.7ap-17h", 0x1.7ap-17}, // +Subnormal - {"-0x1.7ap-17h", -0x1.7ap-17}, // -Subnormal - {"0x1.dp-20h", 0x1.dp-20}, // +Subnormal - {"-0x1.dp-20h", -0x1.dp-20}, // -Subnormal + {"0x0.a8p-19h", 0x0.a8p-19}, // +Subnormal + {"0x1.7ap-17h", 0x1.7ap-17}, // +Subnormal + {"0x1.dp-20h", 0x1.dp-20}, // +Subnormal // F16 exactly representable {"0x1.004p+0h", 0x1.004p+0}, @@ -418,20 +301,14 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x8.06p+0h", 0x8.06p+0}, {"0x2.128p+0h", 0x2.128p+0}, {"0x2.ca8p+0h", 0x2.ca8p+0}, - {"0x0.0fcp-14h", 0x0.0fcp-14}, // Subnormal - {"-0x0.0fcp-14h", -0x0.0fcp-14}, // Subnormal - {"0x3.f00p-20h", 0x3.f00p-20}, // Subnormal - {"-0x3.f00p-20h", -0x3.f00p-20}, // Subnormal + {"0x0.0fcp-14h", 0x0.0fcp-14}, // Subnormal + {"0x3.f00p-20h", 0x3.f00p-20}, // Subnormal // Underflow -> Zero {"0x1p-1075", 0.0}, // Exponent underflows - {"-0x1p-1075", 0.0}, {"0x1p-5000", 0.0}, - {"-0x1p-5000", 0.0}, {"0x0.00000000000000000000001p-1022", 0.0}, // Fraction causes underflow - {"-0x0.0000000000000000000001p-1023", -0.0}, {"0x0.01p-1073", -0.0}, - {"-0x0.01p-1073", -0.0}, // Fraction causes additional underflow {"0x1.0p-9223372036854774784", 0}, // -(INT64_MAX - 1023) (smallest valid exponent) @@ -443,22 +320,14 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x0p-9999999999", 0.0}, // Same, but with very large positive exponents that would cause overflow // if the mantissa were non-zero. - {"0x0p+10000000000000000000", 0.0}, // 10 quintillion (10,000,000,000,000,000,000) - {"0x0p+100000000000000000000", 0.0}, // 100 quintillion (100,000,000,000,000,000,000) - {"-0x0p+100000000000000000000", 0.0}, // As above 2, but negative mantissa - {"-0x0p+1000000000000000000000", 0.0}, + {"0x0p+10000000000000000000", 0.0}, // 10 quintillion (10,000,000,000,000,000,000) + {"0x0p+100000000000000000000", 0.0}, // 100 quintillion (100,000,000,000,000,000,000) {"0x0.00p+10000000000000000000", 0.0}, // As above 4, but with fractional part {"0x0.00p+100000000000000000000", 0.0}, - {"-0x0.00p+100000000000000000000", 0.0}, - {"-0x0.00p+1000000000000000000000", 0.0}, {"0x0p-10000000000000000000", 0.0}, // As above 8, but with negative exponents {"0x0p-100000000000000000000", 0.0}, - {"-0x0p-100000000000000000000", 0.0}, - {"-0x0p-1000000000000000000000", 0.0}, {"0x0.00p-10000000000000000000", 0.0}, {"0x0.00p-100000000000000000000", 0.0}, - {"-0x0.00p-100000000000000000000", 0.0}, - {"-0x0.00p-1000000000000000000000", 0.0}, // Test parsing {"0x0p0", 0.0}, @@ -476,37 +345,24 @@ FloatLiteralTestCaseList HexFloatCases() { {"0x0.4p+1", 2 * 0.25}, {"0x0.4p+2", 4 * 0.25}, {"0x123Ep+1", 9340.0}, - {"-0x123Ep+1", -9340.0}, {"0x1a2b3cP12", 7.024656384e+09}, - {"-0x1a2b3cP12", -7.024656384e+09}, // Examples without a binary exponent part. {"0x1.", 1.0}, {"0x.8", 0.5}, {"0x1.8", 1.5}, - {"-0x1.", -1.0}, - {"-0x.8", -0.5}, - {"-0x1.8", -1.5}, // Examples with a binary exponent and a 'f' suffix. {"0x1.p0f", 1.0}, {"0x.8p2f", 2.0}, {"0x1.8p-1f", 0.75}, {"0x2p-2f", 0.5}, // No binary point - {"-0x1.p0f", -1.0}, - {"-0x.8p2f", -2.0}, - {"-0x1.8p-1f", -0.75}, - {"-0x2p-2f", -0.5}, // No binary point // Examples with a binary exponent and a 'h' suffix. {"0x1.p0h", 1.0}, {"0x.8p2h", 2.0}, {"0x1.8p-1h", 0.75}, {"0x2p-2h", 0.5}, // No binary point - {"-0x1.p0h", -1.0}, - {"-0x.8p2h", -2.0}, - {"-0x1.8p-1h", -0.75}, - {"-0x2p-2h", -0.5}, // No binary point }; } INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_HexFloat, @@ -532,11 +388,9 @@ std::vector UpperCase0X(const ARR& cases) { using UpperCase0XTest = ::testing::Test; TEST_F(UpperCase0XTest, Samples) { const auto cases = FloatLiteralTestCaseList{ - {"absent", 0.0}, {"0x", 1.0}, {"0X", 2.0}, {"-0x", 3.0}, - {"-0X", 4.0}, {" 0x1p1", 5.0}, {" -0x1p", 6.0}, {" examine ", 7.0}}; + {"absent", 0.0}, {"0x", 1.0}, {"0X", 2.0}, {" 0x1p1", 5.0}, {" examine ", 7.0}}; const auto expected = FloatLiteralTestCaseList{ - {"absent", 0.0}, {"0X", 1.0}, {"0X", 2.0}, {"-0X", 3.0}, - {"-0X", 4.0}, {" 0X1p1", 5.0}, {" -0X1p", 6.0}, {" examine ", 7.0}}; + {"absent", 0.0}, {"0X", 1.0}, {"0X", 2.0}, {" 0X1p1", 5.0}, {" examine ", 7.0}}; auto result = UpperCase0X(cases); EXPECT_THAT(result, ::testing::ElementsAreArray(expected)); @@ -625,11 +479,6 @@ INSTANTIATE_TEST_SUITE_P( "0x1.0018p+1024", "0x1.01ep+1024", "0x1.fffffep+1024", - "-0x1.8p+1024", - "-0x1.0002p+1024", - "-0x1.0018p+1024", - "-0x1.01ep+1024", - "-0x1.fffffep+1024", }))); INSTANTIATE_TEST_SUITE_P( @@ -642,11 +491,6 @@ INSTANTIATE_TEST_SUITE_P( "0x1.0018p+128f", "0x1.01ep+128f", "0x1.fffffep+128f", - "-0x1.8p+128f", - "-0x1.0002p+128f", - "-0x1.0018p+128f", - "-0x1.01ep+128f", - "-0x1.fffffep+128f", }))); INSTANTIATE_TEST_SUITE_P( @@ -659,11 +503,6 @@ INSTANTIATE_TEST_SUITE_P( "0x1.018p+16h", "0x1.1ep+16h", "0x1.ffcp+16h", - "-0x1.8p+16h", - "-0x1.004p+16h", - "-0x1.018p+16h", - "-0x1.1ep+16h", - "-0x1.ffcp+16h", }))); INSTANTIATE_TEST_SUITE_P( @@ -672,17 +511,11 @@ INSTANTIATE_TEST_SUITE_P( testing::Combine(testing::Values("1:1: value cannot be represented as 'abstract-float'"), testing::ValuesIn(std::vector{ "0x1p+1024", - "-0x1p+1024", "0x1.1p+1024", - "-0x1.1p+1024", "0x1p+1025", - "-0x1p+1025", "0x32p+1023", - "-0x32p+1023", "0x32p+5000", - "-0x32p+5000", "0x1.0p9223372036854774784", - "-0x1.0p9223372036854774784", }))); INSTANTIATE_TEST_SUITE_P( @@ -691,15 +524,10 @@ INSTANTIATE_TEST_SUITE_P( testing::Combine(testing::Values("1:1: value cannot be represented as 'f32'"), testing::ValuesIn(std::vector{ "0x1p+128f", - "-0x1p+128f", "0x1.1p+128f", - "-0x1.1p+128f", "0x1p+129f", - "-0x1p+129f", "0x32p+127f", - "-0x32p+127f", "0x32p+500f", - "-0x32p+500f", }))); INSTANTIATE_TEST_SUITE_P( @@ -708,15 +536,10 @@ INSTANTIATE_TEST_SUITE_P( testing::Combine(testing::Values("1:1: value cannot be represented as 'f16'"), testing::ValuesIn(std::vector{ "0x1p+16h", - "-0x1p+16h", "0x1.1p+16h", - "-0x1.1p+16h", "0x1p+17h", - "-0x1p+17h", "0x32p+15h", - "-0x32p+15h", "0x32p+500h", - "-0x32p+500h", }))); INSTANTIATE_TEST_SUITE_P( @@ -724,32 +547,22 @@ INSTANTIATE_TEST_SUITE_P( ParserImplInvalidLiteralTest, testing::Combine(testing::Values("1:1: value cannot be exactly represented as 'f32'"), testing::ValuesIn(std::vector{ - "0x1.000001p+0f", // Quantizes to 0x1.0p+0 - "0x1.0000008p+0f", // Quantizes to 0x1.0p+0 - "0x1.0000000000001p+0f", // Quantizes to 0x1.0p+0 - "0x8.0000f8p+0f", // Quantizes to 0x8.0000fp+0 - "0x8.000038p+0f", // Quantizes to 0x8.00003p+0 - "0x2.cafef00dp+0f", // Quantizes to 0x2.cafefp+0 - "0x0.0000ffp-126f", // Subnormal, quantizes to 0x0.0000fep-126 - "0x3.fcp-144f", // Subnormal, quantizes to 0x3.f8p-144 - "-0x0.0000ffp-126f", // Subnormal, quantizes to -0x0.0000fep-126 - "-0x3.fcp-144f", // Subnormal, quantizes to -0x3.f8p-144 - "0x0.ffffffp-126f", // Subnormal, quantizes to 0x0.fffffep-144 - "0x0.fffffe0000001p-126f", // Subnormal, quantizes to 0x0.fffffep-144 - "-0x0.ffffffp-126f", // Subnormal, quantizes to -0x0.fffffep-144 - "-0x0.fffffe0000001p-126f", // Subnormal, quantizes to -0x0.fffffep-144 - "0x1.8p-149f", // Subnormal, quantizes to 0x1.0p-149f - "0x1.4p-149f", // Subnormal, quantizes to 0x1.0p-149f - "0x1.000002p-149f", // Subnormal, quantizes to 0x1.0p-149f - "0x1.0000000000001p-149f", // Subnormal, quantizes to 0x1.0p-149f - "-0x1.8p-149f", // Subnormal, quantizes to -0x1.0p-149f - "-0x1.4p-149f", // Subnormal, quantizes to -0x1.0p-149f - "-0x1.000002p-149f", // Subnormal, quantizes to -0x1.0p-149f - "-0x1.0000000000001p-149f", // Subnormal, quantizes to -0x1.0p-149f - "0x1.0p-150f", // Smaller than the smallest subnormal, quantizes to 0.0 - "0x1.8p-150f", // Smaller than the smallest subnormal, quantizes to 0.0 - "-0x1.0p-150f", // Smaller than the smallest subnormal, quantizes to -0.0 - "-0x1.8p-150f", // Smaller than the smallest subnormal, quantizes to -0.0 + "0x1.000001p+0f", // Quantizes to 0x1.0p+0 + "0x1.0000008p+0f", // Quantizes to 0x1.0p+0 + "0x1.0000000000001p+0f", // Quantizes to 0x1.0p+0 + "0x8.0000f8p+0f", // Quantizes to 0x8.0000fp+0 + "0x8.000038p+0f", // Quantizes to 0x8.00003p+0 + "0x2.cafef00dp+0f", // Quantizes to 0x2.cafefp+0 + "0x0.0000ffp-126f", // Subnormal, quantizes to 0x0.0000fep-126 + "0x3.fcp-144f", // Subnormal, quantizes to 0x3.f8p-144 + "0x0.ffffffp-126f", // Subnormal, quantizes to 0x0.fffffep-144 + "0x0.fffffe0000001p-126f", // Subnormal, quantizes to 0x0.fffffep-144 + "0x1.8p-149f", // Subnormal, quantizes to 0x1.0p-149f + "0x1.4p-149f", // Subnormal, quantizes to 0x1.0p-149f + "0x1.000002p-149f", // Subnormal, quantizes to 0x1.0p-149f + "0x1.0000000000001p-149f", // Subnormal, quantizes to 0x1.0p-149f + "0x1.0p-150f", // Smaller than the smallest subnormal, quantizes to 0.0 + "0x1.8p-150f", // Smaller than the smallest subnormal, quantizes to 0.0 }))); INSTANTIATE_TEST_SUITE_P( @@ -768,26 +581,15 @@ INSTANTIATE_TEST_SUITE_P( "0x4.011p+0h", // Quantizes to 0x4.01p+0 "0x0.0fep-14h", // Subnormal, quantizes to 0x0.0fcp-14 "0x3.f8p-20h", // Subnormal, quantizes to 0x3.f0p-20 - "-0x0.0fep-14h", // Subnormal, quantizes to -0x0.0fcp-14 - "-0x3.f8p-20h", // Subnormal, quantizes to -0x3.f0p-20 "0x0.ffep-14h", // Subnormal, quantizes to 0x0.ffcp-14 "0x0.ffe0000000001p-14h", // Subnormal, quantizes to 0x0.ffcp-14 "0x0.fffffffffffffp-14h", // Subnormal, quantizes to 0x0.ffcp-14 - "-0x0.ffep-14h", // Subnormal, quantizes to -0x0.ffcp-14 - "-0x0.ffe0000000001p-14h", // Subnormal, quantizes to -0x0.ffcp-14 - "-0x0.fffffffffffffp-14h", // Subnormal, quantizes to -0x0.ffcp-14 - "0x1.8p-24h", // Subnormal, quantizes to 0x1.0p-24f - "0x1.4p-24h", // Subnormal, quantizes to 0x1.0p-24f - "0x1.004p-24h", // Subnormal, quantizes to 0x1.0p-24f - "0x1.0000000000001p-24h", // Subnormal, quantizes to 0x1.0p-24f - "-0x1.8p-24h", // Subnormal, quantizes to -0x1.0p-24f - "-0x1.4p-24h", // Subnormal, quantizes to -0x1.0p-24f - "-0x1.004p-24h", // Subnormal, quantizes to -0x1.0p-24f - "-0x1.0000000000001p-24h", // Subnormal, quantizes to -0x1.0p-24f - "0x1.0p-25h", // Smaller than the smallest subnormal, quantizes to 0.0 - "0x1.8p-25h", // Smaller than the smallest subnormal, quantizes to 0.0 - "-0x1.0p-25h", // Smaller than the smallest subnormal, quantizes to -0.0 - "-0x1.8p-25h", // Smaller than the smallest subnormal, quantizes to -0.0 + "0x1.8p-24h", // Subnormal, quantizes to 0x1.0p-24f + "0x1.4p-24h", // Subnormal, quantizes to 0x1.0p-24f + "0x1.004p-24h", // Subnormal, quantizes to 0x1.0p-24f + "0x1.0000000000001p-24h", // Subnormal, quantizes to 0x1.0p-24f + "0x1.0p-25h", // Smaller than the smallest subnormal, quantizes to 0.0 + "0x1.8p-25h", // Smaller than the smallest subnormal, quantizes to 0.0 }))); INSTANTIATE_TEST_SUITE_P( @@ -796,15 +598,10 @@ INSTANTIATE_TEST_SUITE_P( testing::Combine(testing::Values("1:1: value cannot be represented as 'abstract-float'"), testing::ValuesIn(std::vector{ "1.e309", - "-1.e309", "1.8e308", - "-1.8e308", "1.798e308", - "-1.798e308", "1.7977e308", - "-1.7977e308", "1.2e+5000", - "-1.2e+5000", }))); INSTANTIATE_TEST_SUITE_P( @@ -813,15 +610,10 @@ INSTANTIATE_TEST_SUITE_P( testing::Combine(testing::Values("1:1: value cannot be represented as 'f32'"), testing::ValuesIn(std::vector{ "1e39f", - "-1e39f", "4.0e38f", - "-4.0e38f", "3.5e38f", - "-3.5e38f", "3.403e38f", - "-3.403e38f", "1.2e+256f", - "-1.2e+256f", }))); INSTANTIATE_TEST_SUITE_P( @@ -830,17 +622,11 @@ INSTANTIATE_TEST_SUITE_P( testing::Combine(testing::Values("1:1: value cannot be represented as 'f16'"), testing::ValuesIn(std::vector{ "1.0e5h", - "-1.0e5h", "7.0e4h", - "-7.0e4h", "6.6e4h", - "-6.6e4h", "6.56e4h", - "-6.56e4h", "6.554e4h", - "-6.554e4h", "1.2e+32h", - "-1.2e+32h", }))); TEST_F(ParserImplTest, ConstLiteral_FloatHighest) { @@ -863,29 +649,6 @@ TEST_F(ParserImplTest, ConstLiteral_FloatHighest) { EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 42u}})); } -TEST_F(ParserImplTest, ConstLiteral_FloatLowest) { - // Some compilers complain if you test floating point numbers for equality. - // So say it via two inequalities. - const auto lowest = std::numeric_limits::lowest(); - const auto expected_lowest = -340282346638528859811704183484516925440.0f; - if (lowest < expected_lowest || lowest > expected_lowest) { - GTEST_SKIP() << "std::numeric_limits::lowest() is not as expected for " - "this target"; - } - - auto p = parser("-340282346638528859811704183484516925440.0"); - auto c = p->const_literal(); - EXPECT_TRUE(c.matched); - EXPECT_FALSE(c.errored); - EXPECT_FALSE(p->has_error()) << p->error(); - ASSERT_NE(c.value, nullptr); - ASSERT_TRUE(c->Is()); - EXPECT_EQ(c->As()->value, std::numeric_limits::lowest()); - EXPECT_EQ(c->As()->suffix, - ast::FloatLiteralExpression::Suffix::kNone); - EXPECT_EQ(c->source.range, (Source::Range{{1u, 1u}, {1u, 43u}})); -} - TEST_F(ParserImplTest, ConstLiteral_True) { auto p = parser("true"); auto c = p->const_literal(); diff --git a/src/tint/reader/wgsl/parser_impl_expression_test.cc b/src/tint/reader/wgsl/parser_impl_expression_test.cc index 389999fcde..71d1d99ae5 100644 --- a/src/tint/reader/wgsl/parser_impl_expression_test.cc +++ b/src/tint/reader/wgsl/parser_impl_expression_test.cc @@ -269,6 +269,124 @@ TEST_F(ParserImplTest, Expression_InvalidAssociativity) { 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()); + auto* b = e->As(); + EXPECT_TRUE(b->IsSubtract()); + + ASSERT_TRUE(b->lhs->Is()); + ASSERT_TRUE(b->rhs->Is()); + + EXPECT_EQ(b->lhs->As()->value, 2); + EXPECT_EQ(b->rhs->As()->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()); + auto* b = e->As(); + EXPECT_EQ(b->op, ast::UnaryOp::kNegation); + + ASSERT_TRUE(b->expr->Is()); + EXPECT_EQ(b->expr->As()->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()); + EXPECT_EQ(e->As()->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()); + auto* b = e->As(); + EXPECT_EQ(b->op, ast::UnaryOp::kNegation); + + ASSERT_TRUE(b->expr->Is()); + EXPECT_EQ(b->expr->As()->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()); + EXPECT_EQ(e->As()->value, 4294967295); +} + +TEST_F(ParserImplTest, Expression_MaxF32) { + const auto highest = std::numeric_limits::max(); + const auto expected_highest = 340282346638528859811704183484516925440.0f; + if (highest < expected_highest || highest > expected_highest) { + GTEST_SKIP() << "std::numeric_limits::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()); + EXPECT_EQ(e->As()->value, + 340282346638528859811704183484516925440.0f); +} + +TEST_F(ParserImplTest, Expression_MinF32) { + const auto lowest = std::numeric_limits::lowest(); + const auto expected_lowest = -340282346638528859811704183484516925440.0f; + if (lowest < expected_lowest || lowest > expected_lowest) { + GTEST_SKIP() << "std::numeric_limits::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()); + auto* b = e->As(); + EXPECT_EQ(b->op, ast::UnaryOp::kNegation); + + ASSERT_TRUE(b->expr->Is()); + EXPECT_EQ(b->expr->As()->value, + 340282346638528859811704183484516925440.0f); +} + namespace mixing_binary_ops { struct BinaryOperatorInfo { diff --git a/src/tint/resolver/validation_test.cc b/src/tint/resolver/validation_test.cc index d784971048..34ddd90798 100644 --- a/src/tint/resolver/validation_test.cc +++ b/src/tint/resolver/validation_test.cc @@ -1405,6 +1405,27 @@ TEST_F(ResolverTest, Expr_Initializer_Cast_Pointer) { EXPECT_EQ(r()->error(), "12:34 error: type is not constructible"); } +TEST_F(ResolverTest, I32_Overflow) { + GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 2147483648_a)); + + EXPECT_FALSE(r()->Resolve()); + EXPECT_EQ(r()->error(), "12:24 error: value 2147483648 cannot be represented as 'i32'"); +} + +TEST_F(ResolverTest, I32_Underflow) { + GlobalVar("v", ty.i32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, -2147483649_a)); + + EXPECT_FALSE(r()->Resolve()); + EXPECT_EQ(r()->error(), "12:24 error: value -2147483649 cannot be represented as 'i32'"); +} + +TEST_F(ResolverTest, U32_Overflow) { + GlobalVar("v", ty.u32(), ast::AddressSpace::kPrivate, Expr(Source{{12, 24}}, 4294967296_a)); + + EXPECT_FALSE(r()->Resolve()); + EXPECT_EQ(r()->error(), "12:24 error: value 4294967296 cannot be represented as 'u32'"); +} + } // namespace } // namespace tint::resolver diff --git a/test/tint/bug/chromium/1372963.wgsl.expected.wgsl b/test/tint/bug/chromium/1372963.wgsl.expected.wgsl index 955d6c632d..58397f63c5 100644 --- a/test/tint/bug/chromium/1372963.wgsl.expected.wgsl +++ b/test/tint/bug/chromium/1372963.wgsl.expected.wgsl @@ -1,5 +1,5 @@ fn g() -> vec4 { - return (vec4(0) << vec4(2147483649)); + return (vec4(-(0)) << vec4(2147483649)); } @fragment diff --git a/test/tint/bug/dawn/947.wgsl.expected.wgsl b/test/tint/bug/dawn/947.wgsl.expected.wgsl index c1712ae491..98ea24422f 100644 --- a/test/tint/bug/dawn/947.wgsl.expected.wgsl +++ b/test/tint/bug/dawn/947.wgsl.expected.wgsl @@ -14,14 +14,14 @@ struct VertexOutputs { @vertex fn vs_main(@builtin(vertex_index) VertexIndex : u32) -> VertexOutputs { - var texcoord = array, 3>(vec2(-0.5, 0.0), vec2(1.5, 0.0), vec2(0.5, 2.0)); + var texcoord = array, 3>(vec2(-(0.5), 0.0), vec2(1.5, 0.0), vec2(0.5, 2.0)); var output : VertexOutputs; output.position = vec4(((texcoord[VertexIndex] * 2.0) - vec2(1.0, 1.0)), 0.0, 1.0); var flipY = (uniforms.u_scale.y < 0.0); if (flipY) { - output.texcoords = ((((texcoord[VertexIndex] * uniforms.u_scale) + uniforms.u_offset) * vec2(1.0, -1.0)) + vec2(0.0, 1.0)); + output.texcoords = ((((texcoord[VertexIndex] * uniforms.u_scale) + uniforms.u_offset) * vec2(1.0, -(1.0))) + vec2(0.0, 1.0)); } else { - output.texcoords = ((((texcoord[VertexIndex] * vec2(1.0, -1.0)) + vec2(0.0, 1.0)) * uniforms.u_scale) + uniforms.u_offset); + output.texcoords = ((((texcoord[VertexIndex] * vec2(1.0, -(1.0))) + vec2(0.0, 1.0)) * uniforms.u_scale) + uniforms.u_offset); } return output; } diff --git a/test/tint/bug/tint/1113.wgsl.expected.wgsl b/test/tint/bug/tint/1113.wgsl.expected.wgsl index 1d69ccdb63..f1f3077fdc 100644 --- a/test/tint/bug/tint/1113.wgsl.expected.wgsl +++ b/test/tint/bug/tint/1113.wgsl.expected.wgsl @@ -126,7 +126,7 @@ fn main_create_lut(@builtin(global_invocation_id) GlobalInvocationID : vec3 return; } var numTriangles = atomicLoad(&(counters.values[voxelIndex])); - var offset = -1; + var offset = -(1); if ((numTriangles > 0u)) { offset = i32(atomicAdd(&(dbg.offsetCounter), numTriangles)); } diff --git a/test/tint/bug/tint/1121.wgsl.expected.wgsl b/test/tint/bug/tint/1121.wgsl.expected.wgsl index 6156c87c4e..4e5bd4af53 100644 --- a/test/tint/bug/tint/1121.wgsl.expected.wgsl +++ b/test/tint/bug/tint/1121.wgsl.expected.wgsl @@ -53,7 +53,7 @@ fn main(@builtin(global_invocation_id) GlobalInvocationID : vec3) { lightsBuffer.lights[index].position.y = uniforms.max.y; } var M : mat4x4 = uniforms.projectionMatrix; - var viewNear : f32 = (-(M[3][2]) / (-1.0 + M[2][2])); + var viewNear : f32 = (-(M[3][2]) / (-(1.0) + M[2][2])); var viewFar : f32 = (-(M[3][2]) / (1.0 + M[2][2])); var lightPos = lightsBuffer.lights[index].position; lightPos = (uniforms.viewMatrix * lightPos); @@ -62,7 +62,7 @@ fn main(@builtin(global_invocation_id) GlobalInvocationID : vec3) { var boxMin : vec4 = (lightPos - vec4(vec3(lightRadius), 0.0)); var boxMax : vec4 = (lightPos + vec4(vec3(lightRadius), 0.0)); var frustumPlanes : array, 6>; - frustumPlanes[4] = vec4(0.0, 0.0, -1.0, viewNear); + frustumPlanes[4] = vec4(0.0, 0.0, -(1.0), viewNear); frustumPlanes[5] = vec4(0.0, 0.0, 1.0, -(viewFar)); let TILE_SIZE : i32 = 16; let TILE_COUNT_X : i32 = 2; @@ -75,9 +75,9 @@ fn main(@builtin(global_invocation_id) GlobalInvocationID : vec3) { var viewFloorCoord : vec2 = vec2((((-(viewNear) * floorCoord.x) - (M[2][0] * viewNear)) / M[0][0]), (((-(viewNear) * floorCoord.y) - (M[2][1] * viewNear)) / M[1][1])); var viewCeilCoord : vec2 = vec2((((-(viewNear) * ceilCoord.x) - (M[2][0] * viewNear)) / M[0][0]), (((-(viewNear) * ceilCoord.y) - (M[2][1] * viewNear)) / M[1][1])); frustumPlanes[0] = vec4(1.0, 0.0, (-(viewFloorCoord.x) / viewNear), 0.0); - frustumPlanes[1] = vec4(-1.0, 0.0, (viewCeilCoord.x / viewNear), 0.0); + frustumPlanes[1] = vec4(-(1.0), 0.0, (viewCeilCoord.x / viewNear), 0.0); frustumPlanes[2] = vec4(0.0, 1.0, (-(viewFloorCoord.y) / viewNear), 0.0); - frustumPlanes[3] = vec4(0.0, -1.0, (viewCeilCoord.y / viewNear), 0.0); + frustumPlanes[3] = vec4(0.0, -(1.0), (viewCeilCoord.y / viewNear), 0.0); var dp : f32 = 0.0; for(var i : u32 = 0u; (i < 6u); i = (i + 1u)) { var p : vec4; diff --git a/test/tint/bug/tint/1605.wgsl.expected.wgsl b/test/tint/bug/tint/1605.wgsl.expected.wgsl index d7024ec220..942b1dcc92 100644 --- a/test/tint/bug/tint/1605.wgsl.expected.wgsl +++ b/test/tint/bug/tint/1605.wgsl.expected.wgsl @@ -2,7 +2,7 @@ fn func_3() -> bool { for(var i = 0; (i < b); i++) { - for(var j = -1; (j == 1); j++) { + for(var j = -(1); (j == 1); j++) { return false; } } diff --git a/test/tint/bug/tint/1664.wgsl.expected.wgsl b/test/tint/bug/tint/1664.wgsl.expected.wgsl index a6442d71af..50d9f78904 100644 --- a/test/tint/bug/tint/1664.wgsl.expected.wgsl +++ b/test/tint/bug/tint/1664.wgsl.expected.wgsl @@ -7,5 +7,5 @@ fn f0() { fn f1() { let a = 1; - let b = (-2147483648 - a); + let b = (-(2147483648) - a); } diff --git a/test/tint/bug/tint/1666.wgsl.expected.wgsl b/test/tint/bug/tint/1666.wgsl.expected.wgsl index e6f5a2a01e..30ae5d490d 100644 --- a/test/tint/bug/tint/1666.wgsl.expected.wgsl +++ b/test/tint/bug/tint/1666.wgsl.expected.wgsl @@ -17,7 +17,7 @@ fn fixed_size_array() { @group(0) @binding(0) var rarr : array; fn runtime_size_array() { - let idx = -1; + let idx = -(1); let x = rarr[idx]; } diff --git a/test/tint/bug/tint/1703.wgsl.expected.wgsl b/test/tint/bug/tint/1703.wgsl.expected.wgsl index 0692fefa81..7ec273e5d7 100644 --- a/test/tint/bug/tint/1703.wgsl.expected.wgsl +++ b/test/tint/bug/tint/1703.wgsl.expected.wgsl @@ -9,8 +9,8 @@ var my_global : vec4; fn foo_member_initialize() { var vb2 : vec2; vb2.x = (my_global.z != 0); - vb2.x = (my_uniform == -1.0f); - vb2 = vec2((my_uniform == -1.0f), false); + vb2.x = (my_uniform == -(1.0f)); + vb2 = vec2((my_uniform == -(1.0f)), false); if (vb2.x) { let r : vec4 = textureSampleBias(my_texture, my_sampler, vec2(), 0.0); } @@ -19,7 +19,7 @@ fn foo_member_initialize() { fn foo_default_initialize() { var vb2 : vec2; vb2.x = (my_global.z != 0); - vb2.x = (my_uniform == -1.0f); + vb2.x = (my_uniform == -(1.0f)); vb2 = vec2(); if (vb2.x) { let r : vec4 = textureSampleBias(my_texture, my_sampler, vec2(), 0.0); diff --git a/test/tint/bug/tint/403.wgsl.expected.wgsl b/test/tint/bug/tint/403.wgsl.expected.wgsl index a88948337f..67daff7d16 100644 --- a/test/tint/bug/tint/403.wgsl.expected.wgsl +++ b/test/tint/bug/tint/403.wgsl.expected.wgsl @@ -16,7 +16,7 @@ fn main(@builtin(vertex_index) gl_VertexIndex : u32) -> @builtin(position) vec4< let x_23 : mat2x2 = x_20.transform1; let x_28 : mat2x2 = x_26.transform2; let x_46 : u32 = gl_VertexIndex; - indexable = array, 3>(vec2(-1.0, 1.0), vec2(1.0, 1.0), vec2(-1.0, -1.0)); + indexable = array, 3>(vec2(-(1.0), 1.0), vec2(1.0, 1.0), vec2(-(1.0), -(1.0))); let x_51 : vec2 = indexable[x_46]; let x_52 : vec2 = (mat2x2((x_23[0u] + x_28[0u]), (x_23[1u] + x_28[1u])) * x_51); return vec4(x_52.x, x_52.y, 0.0, 1.0); diff --git a/test/tint/bug/tint/824.wgsl.expected.wgsl b/test/tint/bug/tint/824.wgsl.expected.wgsl index 364a7719cc..929857f75f 100644 --- a/test/tint/bug/tint/824.wgsl.expected.wgsl +++ b/test/tint/bug/tint/824.wgsl.expected.wgsl @@ -7,7 +7,7 @@ struct Output { @vertex fn main(@builtin(vertex_index) VertexIndex : u32, @builtin(instance_index) InstanceIndex : u32) -> Output { - let zv : array, 4> = array, 4>(vec2(0.2, 0.2), vec2(0.3, 0.3), vec2(-0.1, -0.1), vec2(1.1, 1.1)); + let zv : array, 4> = array, 4>(vec2(0.2, 0.2), vec2(0.3, 0.3), vec2(-(0.1), -(0.1)), vec2(1.1, 1.1)); let z : f32 = zv[InstanceIndex].x; var output : Output; output.Position = vec4(0.5, 0.5, z, 1.0); diff --git a/test/tint/bug/tint/949.wgsl.expected.wgsl b/test/tint/bug/tint/949.wgsl.expected.wgsl index 710e144575..861a573f3f 100644 --- a/test/tint/bug/tint/949.wgsl.expected.wgsl +++ b/test/tint/bug/tint/949.wgsl.expected.wgsl @@ -305,7 +305,7 @@ fn main_1() { let x_362 : vec3 = output5; let x_365 : mat3x3 = invTBN; let x_366 : vec4 = v_output2; - numSamples = (15.0 + (dot((x_361 * -(x_362)), (x_365 * vec3(x_366.x, x_366.y, x_366.z))) * -11.0)); + numSamples = (15.0 + (dot((x_361 * -(x_362)), (x_365 * vec3(x_366.x, x_366.y, x_366.z))) * -(11.0))); let x_374 : f32 = numSamples; stepSize = (1.0 / x_374); currRayHeight = 1.0; diff --git a/test/tint/expressions/binary/add/mat3x3-mat3x3/f16.wgsl.expected.wgsl b/test/tint/expressions/binary/add/mat3x3-mat3x3/f16.wgsl.expected.wgsl index 202712af77..77245fe89a 100644 --- a/test/tint/expressions/binary/add/mat3x3-mat3x3/f16.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/add/mat3x3-mat3x3/f16.wgsl.expected.wgsl @@ -3,6 +3,6 @@ enable f16; @compute @workgroup_size(1) fn f() { let a = mat3x3(vec3(1.0h, 2.0h, 3.0h), vec3(4.0h, 5.0h, 6.0h), vec3(7.0h, 8.0h, 9.0h)); - let b = mat3x3(vec3(-1.0h, -2.0h, -3.0h), vec3(-4.0h, -5.0h, -6.0h), vec3(-7.0h, -8.0h, -9.0h)); + let b = mat3x3(vec3(-(1.0h), -(2.0h), -(3.0h)), vec3(-(4.0h), -(5.0h), -(6.0h)), vec3(-(7.0h), -(8.0h), -(9.0h))); let r : mat3x3 = (a + b); } diff --git a/test/tint/expressions/binary/add/mat3x3-mat3x3/f32.wgsl.expected.wgsl b/test/tint/expressions/binary/add/mat3x3-mat3x3/f32.wgsl.expected.wgsl index 8aa0a4c3f6..2f3c573f2a 100644 --- a/test/tint/expressions/binary/add/mat3x3-mat3x3/f32.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/add/mat3x3-mat3x3/f32.wgsl.expected.wgsl @@ -1,6 +1,6 @@ @compute @workgroup_size(1) fn f() { let a = mat3x3(vec3(1.0, 2.0, 3.0), vec3(4.0, 5.0, 6.0), vec3(7.0, 8.0, 9.0)); - let b = mat3x3(vec3(-1.0, -2.0, -3.0), vec3(-4.0, -5.0, -6.0), vec3(-7.0, -8.0, -9.0)); + let b = mat3x3(vec3(-(1.0), -(2.0), -(3.0)), vec3(-(4.0), -(5.0), -(6.0)), vec3(-(7.0), -(8.0), -(9.0))); let r : mat3x3 = (a + b); } diff --git a/test/tint/expressions/binary/mul/mat2x4-mat4x2/f16.wgsl.expected.wgsl b/test/tint/expressions/binary/mul/mat2x4-mat4x2/f16.wgsl.expected.wgsl index c63d459ef1..3ef345bfdd 100644 --- a/test/tint/expressions/binary/mul/mat2x4-mat4x2/f16.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/mul/mat2x4-mat4x2/f16.wgsl.expected.wgsl @@ -3,6 +3,6 @@ enable f16; @compute @workgroup_size(1) fn f() { let a = mat2x4(vec4(1.0h, 2.0h, 3.0h, 4.0h), vec4(5.0h, 6.0h, 7.0h, 8.0h)); - let b = mat4x2(vec2(-1.0h, -2.0h), vec2(-3.0h, -4.0h), vec2(-5.0h, -6.0h), vec2(-7.0h, -8.0h)); + let b = mat4x2(vec2(-(1.0h), -(2.0h)), vec2(-(3.0h), -(4.0h)), vec2(-(5.0h), -(6.0h)), vec2(-(7.0h), -(8.0h))); let r : mat4x4 = (a * b); } diff --git a/test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.wgsl b/test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.wgsl index 46edcc4cfc..f9b192cf55 100644 --- a/test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.wgsl @@ -1,6 +1,6 @@ @compute @workgroup_size(1) fn f() { let a = mat2x4(vec4(1.0, 2.0, 3.0, 4.0), vec4(5.0, 6.0, 7.0, 8.0)); - let b = mat4x2(vec2(-1.0, -2.0), vec2(-3.0, -4.0), vec2(-5.0, -6.0), vec2(-7.0, -8.0)); + let b = mat4x2(vec2(-(1.0), -(2.0)), vec2(-(3.0), -(4.0)), vec2(-(5.0), -(6.0)), vec2(-(7.0), -(8.0))); let r : mat4x4 = (a * b); } diff --git a/test/tint/expressions/binary/mul/mat3x3-mat3x3/f16.wgsl.expected.wgsl b/test/tint/expressions/binary/mul/mat3x3-mat3x3/f16.wgsl.expected.wgsl index aef6f82a30..ffc08adf6a 100644 --- a/test/tint/expressions/binary/mul/mat3x3-mat3x3/f16.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/mul/mat3x3-mat3x3/f16.wgsl.expected.wgsl @@ -3,6 +3,6 @@ enable f16; @compute @workgroup_size(1) fn f() { let a = mat3x3(vec3(1.0h, 2.0h, 3.0h), vec3(4.0h, 5.0h, 6.0h), vec3(7.0h, 8.0h, 9.0h)); - let b = mat3x3(vec3(-1.0h, -2.0h, -3.0h), vec3(-4.0h, -5.0h, -6.0h), vec3(-7.0h, -8.0h, -9.0h)); + let b = mat3x3(vec3(-(1.0h), -(2.0h), -(3.0h)), vec3(-(4.0h), -(5.0h), -(6.0h)), vec3(-(7.0h), -(8.0h), -(9.0h))); let r : mat3x3 = (a * b); } diff --git a/test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.wgsl b/test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.wgsl index 32653664f6..d3058a7902 100644 --- a/test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.wgsl @@ -1,6 +1,6 @@ @compute @workgroup_size(1) fn f() { let a = mat3x3(vec3(1.0, 2.0, 3.0), vec3(4.0, 5.0, 6.0), vec3(7.0, 8.0, 9.0)); - let b = mat3x3(vec3(-1.0, -2.0, -3.0), vec3(-4.0, -5.0, -6.0), vec3(-7.0, -8.0, -9.0)); + let b = mat3x3(vec3(-(1.0), -(2.0), -(3.0)), vec3(-(4.0), -(5.0), -(6.0)), vec3(-(7.0), -(8.0), -(9.0))); let r : mat3x3 = (a * b); } diff --git a/test/tint/expressions/binary/mul/mat4x2-mat2x4/f16.wgsl.expected.wgsl b/test/tint/expressions/binary/mul/mat4x2-mat2x4/f16.wgsl.expected.wgsl index 87b308aae8..d74dec76a4 100644 --- a/test/tint/expressions/binary/mul/mat4x2-mat2x4/f16.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/mul/mat4x2-mat2x4/f16.wgsl.expected.wgsl @@ -2,7 +2,7 @@ enable f16; @compute @workgroup_size(1) fn f() { - let a = mat4x2(vec2(-1.0h, -2.0h), vec2(-3.0h, -4.0h), vec2(-5.0h, -6.0h), vec2(-7.0h, -8.0h)); + let a = mat4x2(vec2(-(1.0h), -(2.0h)), vec2(-(3.0h), -(4.0h)), vec2(-(5.0h), -(6.0h)), vec2(-(7.0h), -(8.0h))); let b = mat2x4(vec4(1.0h, 2.0h, 3.0h, 4.0h), vec4(5.0h, 6.0h, 7.0h, 8.0h)); let r : mat2x2 = (a * b); } diff --git a/test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.wgsl b/test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.wgsl index 0e59163060..8f335af735 100644 --- a/test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.wgsl @@ -1,6 +1,6 @@ @compute @workgroup_size(1) fn f() { - let a = mat4x2(vec2(-1.0, -2.0), vec2(-3.0, -4.0), vec2(-5.0, -6.0), vec2(-7.0, -8.0)); + let a = mat4x2(vec2(-(1.0), -(2.0)), vec2(-(3.0), -(4.0)), vec2(-(5.0), -(6.0)), vec2(-(7.0), -(8.0))); let b = mat2x4(vec4(1.0, 2.0, 3.0, 4.0), vec4(5.0, 6.0, 7.0, 8.0)); let r : mat2x2 = (a * b); } diff --git a/test/tint/expressions/binary/sub/mat3x3-mat3x3/f16.wgsl.expected.wgsl b/test/tint/expressions/binary/sub/mat3x3-mat3x3/f16.wgsl.expected.wgsl index 22415884bd..284a03ed3a 100644 --- a/test/tint/expressions/binary/sub/mat3x3-mat3x3/f16.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/sub/mat3x3-mat3x3/f16.wgsl.expected.wgsl @@ -3,6 +3,6 @@ enable f16; @compute @workgroup_size(1) fn f() { let a = mat3x3(vec3(1.0h, 2.0h, 3.0h), vec3(4.0h, 5.0h, 6.0h), vec3(7.0h, 8.0h, 9.0h)); - let b = mat3x3(vec3(-1.0h, -2.0h, -3.0h), vec3(-4.0h, -5.0h, -6.0h), vec3(-7.0h, -8.0h, -9.0h)); + let b = mat3x3(vec3(-(1.0h), -(2.0h), -(3.0h)), vec3(-(4.0h), -(5.0h), -(6.0h)), vec3(-(7.0h), -(8.0h), -(9.0h))); let r : mat3x3 = (a - b); } diff --git a/test/tint/expressions/binary/sub/mat3x3-mat3x3/f32.wgsl.expected.wgsl b/test/tint/expressions/binary/sub/mat3x3-mat3x3/f32.wgsl.expected.wgsl index 014521028f..adddeb367a 100644 --- a/test/tint/expressions/binary/sub/mat3x3-mat3x3/f32.wgsl.expected.wgsl +++ b/test/tint/expressions/binary/sub/mat3x3-mat3x3/f32.wgsl.expected.wgsl @@ -1,6 +1,6 @@ @compute @workgroup_size(1) fn f() { let a = mat3x3(vec3(1.0, 2.0, 3.0), vec3(4.0, 5.0, 6.0), vec3(7.0, 8.0, 9.0)); - let b = mat3x3(vec3(-1.0, -2.0, -3.0), vec3(-4.0, -5.0, -6.0), vec3(-7.0, -8.0, -9.0)); + let b = mat3x3(vec3(-(1.0), -(2.0), -(3.0)), vec3(-(4.0), -(5.0), -(6.0)), vec3(-(7.0), -(8.0), -(9.0))); let r : mat3x3 = (a - b); } diff --git a/test/tint/expressions/bitcast/scalar/i32min-u32.wgsl.expected.wgsl b/test/tint/expressions/bitcast/scalar/i32min-u32.wgsl.expected.wgsl index 374110c184..5e19baa274 100644 --- a/test/tint/expressions/bitcast/scalar/i32min-u32.wgsl.expected.wgsl +++ b/test/tint/expressions/bitcast/scalar/i32min-u32.wgsl.expected.wgsl @@ -1,4 +1,4 @@ @compute @workgroup_size(1) fn f() { - let b : u32 = bitcast(-2147483648); + let b : u32 = bitcast(-(2147483648)); } diff --git a/test/tint/expressions/literals/intmin.wgsl.expected.wgsl b/test/tint/expressions/literals/intmin.wgsl.expected.wgsl index b3834c1420..eafbdc1504 100644 --- a/test/tint/expressions/literals/intmin.wgsl.expected.wgsl +++ b/test/tint/expressions/literals/intmin.wgsl.expected.wgsl @@ -1,6 +1,6 @@ fn add_int_min_explicit() -> i32 { - var a = -2147483648; + var a = -(2147483648); var b = (a + 1); - var c = (-2147483648 + 1); + var c = (-(2147483648) + 1); return c; } diff --git a/test/tint/samples/compute_boids.wgsl.expected.wgsl b/test/tint/samples/compute_boids.wgsl.expected.wgsl index 253d6f0218..fd43650a1c 100644 --- a/test/tint/samples/compute_boids.wgsl.expected.wgsl +++ b/test/tint/samples/compute_boids.wgsl.expected.wgsl @@ -77,17 +77,17 @@ fn comp_main(@builtin(global_invocation_id) gl_GlobalInvocationID : vec3) { vVel = (((vVel + (cMass * params.rule1Scale)) + (colVel * params.rule2Scale)) + (cVel * params.rule3Scale)); vVel = (normalize(vVel) * clamp(length(vVel), 0.0, 0.1)); vPos = (vPos + (vVel * params.deltaT)); - if ((vPos.x < -1.0)) { + if ((vPos.x < -(1.0))) { vPos.x = 1.0; } if ((vPos.x > 1.0)) { - vPos.x = -1.0; + vPos.x = -(1.0); } - if ((vPos.y < -1.0)) { + if ((vPos.y < -(1.0))) { vPos.y = 1.0; } if ((vPos.y > 1.0)) { - vPos.y = -1.0; + vPos.y = -(1.0); } particlesB.particles[index].pos = vPos; particlesB.particles[index].vel = vVel; diff --git a/test/tint/samples/triangle.wgsl.expected.wgsl b/test/tint/samples/triangle.wgsl.expected.wgsl index dcdf48cb69..852014c774 100644 --- a/test/tint/samples/triangle.wgsl.expected.wgsl +++ b/test/tint/samples/triangle.wgsl.expected.wgsl @@ -1,4 +1,4 @@ -const pos = array, 3>(vec2(0.0, 0.5), vec2(-0.5, -0.5), vec2(0.5, -0.5)); +const pos = array, 3>(vec2(0.0, 0.5), vec2(-(0.5), -(0.5)), vec2(0.5, -(0.5))); @vertex fn vtx_main(@builtin(vertex_index) VertexIndex : u32) -> @builtin(position) vec4 {