encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update lexer to not include `-` in numbers. 

This CL removes the parsing of a `-` in front of numerics when lexed.
This will cause the number to become a UnaryOperator negation then the
number instead of a negative number.

Bug: tint:1679, tint:1141, tint:1570
Change-Id: I217c0ffcbe5be934c8d56bd83141b47ade83bc60
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/106463
Reviewed-by: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair 2022-10-26 15:20:47 +00:00 committed by Dawn LUCI CQ
parent 63463c2f77
commit b3b027d3cd
33 changed files with 248 additions and 425 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/tint/fuzzers/tint_ast_fuzzer/mutations/change_unary_operator_test.cc
View File

@ -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<i32> = vec3<i32>(1, 3, -1);
let b : vec3<i32> = vec3<i32>(1, 3, -(1));
var comp_b : vec3<i32> = -(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<i32> = vec3<i32>(1, 3, -1);
var b : vec3<i32> = vec3<i32>(1, 3, -(1));
let neg_b : vec3<i32> = ~(b);
}
)";

4
src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator_test.cc
View File

@ -260,7 +260,7 @@ TEST(WrapUnaryOperatorTest, Applicable6) {
ASSERT_TRUE(result.success) << result.error;
std::string expected_shader = R"(fn main() {
var a : vec4<f32> = -(vec4<f32>(-1.0, -1.0, -1.0, -1.0));
var a : vec4<f32> = -(vec4<f32>(-(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<i32> = ~(vec4<i32>(1, 0, -1, 0));
var a : vec4<i32> = ~(vec4<i32>(1, 0, -(1), 0));
}
)";
ASSERT_EQ(expected_shader, result.wgsl);

24
src/tint/reader/wgsl/lexer.cc
View File

@ -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<uint64_t>(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 {};
}

67
src/tint/reader/wgsl/lexer_test.cc
View File

@ -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<double>(5.7f)},
FloatData{"5.f", static_cast<double>(5.f)},
FloatData{".7f", static_cast<double>(.7f)},
FloatData{"-5.7f", static_cast<double>(-5.7f)},
FloatData{"-5.f", static_cast<double>(-5.f)},
FloatData{"-.7f", static_cast<double>(-.7f)},
// Non-zero with decimal and 'h' suffix
FloatData{"5.7h", static_cast<double>(f16::Quantize(5.7f))},
FloatData{"5.h", static_cast<double>(f16::Quantize(5.f))},
FloatData{".7h", static_cast<double>(f16::Quantize(.7f))},
FloatData{"-5.7h", static_cast<double>(f16::Quantize(-5.7f))},
FloatData{"-5.h", static_cast<double>(f16::Quantize(-5.f))},
FloatData{"-.7h", static_cast<double>(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<ParseIntegerCase>{
{"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<ParseIntegerCase>{
{"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<ParseIntegerCase>{
{"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;

2
src/tint/reader/wgsl/parser_impl_argument_expression_list_test.cc
View File

@ -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);

359
src/tint/reader/wgsl/parser_impl_const_literal_test.cc
View File

@ -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<ast::IntLiteralExpression>());
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->value, -234);
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->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<ast::IntLiteralExpression>());
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->value, -234);
EXPECT_EQ(c->As<ast::IntLiteralExpression>()->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<FloatLiteralTestCase>;
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<double>(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<double>(1e38f)},
{"-1e38f", static_cast<double>(-1e38f)},
{"4.0e37f", static_cast<double>(4.0e37f)},
{"-4.0e37f", static_cast<double>(-4.0e37f)},
{"3.5e37f", static_cast<double>(3.5e37f)},
{"-3.5e37f", static_cast<double>(-3.5e37f)},
{"3.403e37f", static_cast<double>(3.403e37f)},
{"-3.403e37f", static_cast<double>(-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<FloatLiteralTestCase> 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<const char*>{
"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<const char*>{
"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<const char*>{
"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<const char*>{
"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<const char*>{
"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<const char*>{
"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<const char*>{
"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<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.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<ast::FloatLiteralExpression>());
EXPECT_EQ(c->As<ast::FloatLiteralExpression>()->value, std::numeric_limits<float>::lowest());
EXPECT_EQ(c->As<ast::FloatLiteralExpression>()->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();

118
src/tint/reader/wgsl/parser_impl_expression_test.cc
View File

@ -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<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 {

21
src/tint/resolver/validation_test.cc
View File

@ -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

2
test/tint/bug/chromium/1372963.wgsl.expected.wgsl
View File

@ -1,5 +1,5 @@
fn g() -> vec4<i32> {
return (vec4(0) << vec4(2147483649));
return (vec4(-(0)) << vec4(2147483649));
}
@fragment

6
test/tint/bug/dawn/947.wgsl.expected.wgsl
View File

@ -14,14 +14,14 @@ struct VertexOutputs {
@vertex
fn vs_main(@builtin(vertex_index) VertexIndex : u32) -> VertexOutputs {
var texcoord = array<vec2<f32>, 3>(vec2<f32>(-0.5, 0.0), vec2<f32>(1.5, 0.0), vec2<f32>(0.5, 2.0));
var texcoord = array<vec2<f32>, 3>(vec2<f32>(-(0.5), 0.0), vec2<f32>(1.5, 0.0), vec2<f32>(0.5, 2.0));
var output : VertexOutputs;
output.position = vec4<f32>(((texcoord[VertexIndex] * 2.0) - vec2<f32>(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<f32>(1.0, -1.0)) + vec2<f32>(0.0, 1.0));
output.texcoords = ((((texcoord[VertexIndex] * uniforms.u_scale) + uniforms.u_offset) * vec2<f32>(1.0, -(1.0))) + vec2<f32>(0.0, 1.0));
} else {
output.texcoords = ((((texcoord[VertexIndex] * vec2<f32>(1.0, -1.0)) + vec2<f32>(0.0, 1.0)) * uniforms.u_scale) + uniforms.u_offset);
output.texcoords = ((((texcoord[VertexIndex] * vec2<f32>(1.0, -(1.0))) + vec2<f32>(0.0, 1.0)) * uniforms.u_scale) + uniforms.u_offset);
}
return output;
}

2
test/tint/bug/tint/1113.wgsl.expected.wgsl
View File

@ -126,7 +126,7 @@ fn main_create_lut(@builtin(global_invocation_id) GlobalInvocationID : vec3<u32>
return;
}
var numTriangles = atomicLoad(&(counters.values[voxelIndex]));
var offset = -1;
var offset = -(1);
if ((numTriangles > 0u)) {
offset = i32(atomicAdd(&(dbg.offsetCounter), numTriangles));
}

8
test/tint/bug/tint/1121.wgsl.expected.wgsl
View File

@ -53,7 +53,7 @@ fn main(@builtin(global_invocation_id) GlobalInvocationID : vec3<u32>) {
lightsBuffer.lights[index].position.y = uniforms.max.y;
}
var M : mat4x4<f32> = 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<u32>) {
var boxMin : vec4<f32> = (lightPos - vec4<f32>(vec3<f32>(lightRadius), 0.0));
var boxMax : vec4<f32> = (lightPos + vec4<f32>(vec3<f32>(lightRadius), 0.0));
var frustumPlanes : array<vec4<f32>, 6>;
frustumPlanes[4] = vec4<f32>(0.0, 0.0, -1.0, viewNear);
frustumPlanes[4] = vec4<f32>(0.0, 0.0, -(1.0), viewNear);
frustumPlanes[5] = vec4<f32>(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<u32>) {
var viewFloorCoord : vec2<f32> = vec2<f32>((((-(viewNear) * floorCoord.x) - (M[2][0] * viewNear)) / M[0][0]), (((-(viewNear) * floorCoord.y) - (M[2][1] * viewNear)) / M[1][1]));
var viewCeilCoord : vec2<f32> = vec2<f32>((((-(viewNear) * ceilCoord.x) - (M[2][0] * viewNear)) / M[0][0]), (((-(viewNear) * ceilCoord.y) - (M[2][1] * viewNear)) / M[1][1]));
frustumPlanes[0] = vec4<f32>(1.0, 0.0, (-(viewFloorCoord.x) / viewNear), 0.0);
frustumPlanes[1] = vec4<f32>(-1.0, 0.0, (viewCeilCoord.x / viewNear), 0.0);
frustumPlanes[1] = vec4<f32>(-(1.0), 0.0, (viewCeilCoord.x / viewNear), 0.0);
frustumPlanes[2] = vec4<f32>(0.0, 1.0, (-(viewFloorCoord.y) / viewNear), 0.0);
frustumPlanes[3] = vec4<f32>(0.0, -1.0, (viewCeilCoord.y / viewNear), 0.0);
frustumPlanes[3] = vec4<f32>(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<f32>;

2
test/tint/bug/tint/1605.wgsl.expected.wgsl
View File

@ -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;
}
}

2
test/tint/bug/tint/1664.wgsl.expected.wgsl
View File

@ -7,5 +7,5 @@ fn f0() {
fn f1() {
let a = 1;
let b = (-2147483648 - a);
let b = (-(2147483648) - a);
}

2
test/tint/bug/tint/1666.wgsl.expected.wgsl
View File

@ -17,7 +17,7 @@ fn fixed_size_array() {
@group(0) @binding(0) var<storage> rarr : array<f32>;
fn runtime_size_array() {
let idx = -1;
let idx = -(1);
let x = rarr[idx];
}

6
test/tint/bug/tint/1703.wgsl.expected.wgsl
View File

@ -9,8 +9,8 @@ var<private> my_global : vec4<f32>;
fn foo_member_initialize() {
var vb2 : vec2<bool>;
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<f32> = textureSampleBias(my_texture, my_sampler, vec2<f32>(), 0.0);
}
@ -19,7 +19,7 @@ fn foo_member_initialize() {
fn foo_default_initialize() {
var vb2 : vec2<bool>;
vb2.x = (my_global.z != 0);
vb2.x = (my_uniform == -1.0f);
vb2.x = (my_uniform == -(1.0f));
vb2 = vec2<bool>();
if (vb2.x) {
let r : vec4<f32> = textureSampleBias(my_texture, my_sampler, vec2<f32>(), 0.0);

2
test/tint/bug/tint/403.wgsl.expected.wgsl
View File

@ -16,7 +16,7 @@ fn main(@builtin(vertex_index) gl_VertexIndex : u32) -> @builtin(position) vec4<
let x_23 : mat2x2<f32> = x_20.transform1;
let x_28 : mat2x2<f32> = x_26.transform2;
let x_46 : u32 = gl_VertexIndex;
indexable = array<vec2<f32>, 3>(vec2<f32>(-1.0, 1.0), vec2<f32>(1.0, 1.0), vec2<f32>(-1.0, -1.0));
indexable = array<vec2<f32>, 3>(vec2<f32>(-(1.0), 1.0), vec2<f32>(1.0, 1.0), vec2<f32>(-(1.0), -(1.0)));
let x_51 : vec2<f32> = indexable[x_46];
let x_52 : vec2<f32> = (mat2x2<f32>((x_23[0u] + x_28[0u]), (x_23[1u] + x_28[1u])) * x_51);
return vec4<f32>(x_52.x, x_52.y, 0.0, 1.0);

2
test/tint/bug/tint/824.wgsl.expected.wgsl
View File

@ -7,7 +7,7 @@ struct Output {
@vertex
fn main(@builtin(vertex_index) VertexIndex : u32, @builtin(instance_index) InstanceIndex : u32) -> Output {
let zv : array<vec2<f32>, 4> = array<vec2<f32>, 4>(vec2<f32>(0.2, 0.2), vec2<f32>(0.3, 0.3), vec2<f32>(-0.1, -0.1), vec2<f32>(1.1, 1.1));
let zv : array<vec2<f32>, 4> = array<vec2<f32>, 4>(vec2<f32>(0.2, 0.2), vec2<f32>(0.3, 0.3), vec2<f32>(-(0.1), -(0.1)), vec2<f32>(1.1, 1.1));
let z : f32 = zv[InstanceIndex].x;
var output : Output;
output.Position = vec4<f32>(0.5, 0.5, z, 1.0);

2
test/tint/bug/tint/949.wgsl.expected.wgsl
View File

@ -305,7 +305,7 @@ fn main_1() {
let x_362 : vec3<f32> = output5;
let x_365 : mat3x3<f32> = invTBN;
let x_366 : vec4<f32> = v_output2;
numSamples = (15.0 + (dot((x_361 * -(x_362)), (x_365 * vec3<f32>(x_366.x, x_366.y, x_366.z))) * -11.0));
numSamples = (15.0 + (dot((x_361 * -(x_362)), (x_365 * vec3<f32>(x_366.x, x_366.y, x_366.z))) * -(11.0)));
let x_374 : f32 = numSamples;
stepSize = (1.0 / x_374);
currRayHeight = 1.0;

2
test/tint/expressions/binary/add/mat3x3-mat3x3/f16.wgsl.expected.wgsl
View File

@ -3,6 +3,6 @@ enable f16;
@compute @workgroup_size(1)
fn f() {
let a = mat3x3<f16>(vec3<f16>(1.0h, 2.0h, 3.0h), vec3<f16>(4.0h, 5.0h, 6.0h), vec3<f16>(7.0h, 8.0h, 9.0h));
let b = mat3x3<f16>(vec3<f16>(-1.0h, -2.0h, -3.0h), vec3<f16>(-4.0h, -5.0h, -6.0h), vec3<f16>(-7.0h, -8.0h, -9.0h));
let b = mat3x3<f16>(vec3<f16>(-(1.0h), -(2.0h), -(3.0h)), vec3<f16>(-(4.0h), -(5.0h), -(6.0h)), vec3<f16>(-(7.0h), -(8.0h), -(9.0h)));
let r : mat3x3<f16> = (a + b);
}

2
test/tint/expressions/binary/add/mat3x3-mat3x3/f32.wgsl.expected.wgsl
View File

@ -1,6 +1,6 @@
@compute @workgroup_size(1)
fn f() {
let a = mat3x3<f32>(vec3<f32>(1.0, 2.0, 3.0), vec3<f32>(4.0, 5.0, 6.0), vec3<f32>(7.0, 8.0, 9.0));
let b = mat3x3<f32>(vec3<f32>(-1.0, -2.0, -3.0), vec3<f32>(-4.0, -5.0, -6.0), vec3<f32>(-7.0, -8.0, -9.0));
let b = mat3x3<f32>(vec3<f32>(-(1.0), -(2.0), -(3.0)), vec3<f32>(-(4.0), -(5.0), -(6.0)), vec3<f32>(-(7.0), -(8.0), -(9.0)));
let r : mat3x3<f32> = (a + b);
}

2
test/tint/expressions/binary/mul/mat2x4-mat4x2/f16.wgsl.expected.wgsl
View File

@ -3,6 +3,6 @@ enable f16;
@compute @workgroup_size(1)
fn f() {
let a = mat2x4<f16>(vec4<f16>(1.0h, 2.0h, 3.0h, 4.0h), vec4<f16>(5.0h, 6.0h, 7.0h, 8.0h));
let b = mat4x2<f16>(vec2<f16>(-1.0h, -2.0h), vec2<f16>(-3.0h, -4.0h), vec2<f16>(-5.0h, -6.0h), vec2<f16>(-7.0h, -8.0h));
let b = mat4x2<f16>(vec2<f16>(-(1.0h), -(2.0h)), vec2<f16>(-(3.0h), -(4.0h)), vec2<f16>(-(5.0h), -(6.0h)), vec2<f16>(-(7.0h), -(8.0h)));
let r : mat4x4<f16> = (a * b);
}

2
test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.wgsl
View File

@ -1,6 +1,6 @@
@compute @workgroup_size(1)
fn f() {
let a = mat2x4<f32>(vec4<f32>(1.0, 2.0, 3.0, 4.0), vec4<f32>(5.0, 6.0, 7.0, 8.0));
let b = mat4x2<f32>(vec2<f32>(-1.0, -2.0), vec2<f32>(-3.0, -4.0), vec2<f32>(-5.0, -6.0), vec2<f32>(-7.0, -8.0));
let b = mat4x2<f32>(vec2<f32>(-(1.0), -(2.0)), vec2<f32>(-(3.0), -(4.0)), vec2<f32>(-(5.0), -(6.0)), vec2<f32>(-(7.0), -(8.0)));
let r : mat4x4<f32> = (a * b);
}

2
test/tint/expressions/binary/mul/mat3x3-mat3x3/f16.wgsl.expected.wgsl
View File

@ -3,6 +3,6 @@ enable f16;
@compute @workgroup_size(1)
fn f() {
let a = mat3x3<f16>(vec3<f16>(1.0h, 2.0h, 3.0h), vec3<f16>(4.0h, 5.0h, 6.0h), vec3<f16>(7.0h, 8.0h, 9.0h));
let b = mat3x3<f16>(vec3<f16>(-1.0h, -2.0h, -3.0h), vec3<f16>(-4.0h, -5.0h, -6.0h), vec3<f16>(-7.0h, -8.0h, -9.0h));
let b = mat3x3<f16>(vec3<f16>(-(1.0h), -(2.0h), -(3.0h)), vec3<f16>(-(4.0h), -(5.0h), -(6.0h)), vec3<f16>(-(7.0h), -(8.0h), -(9.0h)));
let r : mat3x3<f16> = (a * b);
}

2
test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.wgsl
View File

@ -1,6 +1,6 @@
@compute @workgroup_size(1)
fn f() {
let a = mat3x3<f32>(vec3<f32>(1.0, 2.0, 3.0), vec3<f32>(4.0, 5.0, 6.0), vec3<f32>(7.0, 8.0, 9.0));
let b = mat3x3<f32>(vec3<f32>(-1.0, -2.0, -3.0), vec3<f32>(-4.0, -5.0, -6.0), vec3<f32>(-7.0, -8.0, -9.0));
let b = mat3x3<f32>(vec3<f32>(-(1.0), -(2.0), -(3.0)), vec3<f32>(-(4.0), -(5.0), -(6.0)), vec3<f32>(-(7.0), -(8.0), -(9.0)));
let r : mat3x3<f32> = (a * b);
}

2
test/tint/expressions/binary/mul/mat4x2-mat2x4/f16.wgsl.expected.wgsl
View File

@ -2,7 +2,7 @@ enable f16;
@compute @workgroup_size(1)
fn f() {
let a = mat4x2<f16>(vec2<f16>(-1.0h, -2.0h), vec2<f16>(-3.0h, -4.0h), vec2<f16>(-5.0h, -6.0h), vec2<f16>(-7.0h, -8.0h));
let a = mat4x2<f16>(vec2<f16>(-(1.0h), -(2.0h)), vec2<f16>(-(3.0h), -(4.0h)), vec2<f16>(-(5.0h), -(6.0h)), vec2<f16>(-(7.0h), -(8.0h)));
let b = mat2x4<f16>(vec4<f16>(1.0h, 2.0h, 3.0h, 4.0h), vec4<f16>(5.0h, 6.0h, 7.0h, 8.0h));
let r : mat2x2<f16> = (a * b);
}

2
test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.wgsl
View File

@ -1,6 +1,6 @@
@compute @workgroup_size(1)
fn f() {
let a = mat4x2<f32>(vec2<f32>(-1.0, -2.0), vec2<f32>(-3.0, -4.0), vec2<f32>(-5.0, -6.0), vec2<f32>(-7.0, -8.0));
let a = mat4x2<f32>(vec2<f32>(-(1.0), -(2.0)), vec2<f32>(-(3.0), -(4.0)), vec2<f32>(-(5.0), -(6.0)), vec2<f32>(-(7.0), -(8.0)));
let b = mat2x4<f32>(vec4<f32>(1.0, 2.0, 3.0, 4.0), vec4<f32>(5.0, 6.0, 7.0, 8.0));
let r : mat2x2<f32> = (a * b);
}

2
test/tint/expressions/binary/sub/mat3x3-mat3x3/f16.wgsl.expected.wgsl
View File

@ -3,6 +3,6 @@ enable f16;
@compute @workgroup_size(1)
fn f() {
let a = mat3x3<f16>(vec3<f16>(1.0h, 2.0h, 3.0h), vec3<f16>(4.0h, 5.0h, 6.0h), vec3<f16>(7.0h, 8.0h, 9.0h));
let b = mat3x3<f16>(vec3<f16>(-1.0h, -2.0h, -3.0h), vec3<f16>(-4.0h, -5.0h, -6.0h), vec3<f16>(-7.0h, -8.0h, -9.0h));
let b = mat3x3<f16>(vec3<f16>(-(1.0h), -(2.0h), -(3.0h)), vec3<f16>(-(4.0h), -(5.0h), -(6.0h)), vec3<f16>(-(7.0h), -(8.0h), -(9.0h)));
let r : mat3x3<f16> = (a - b);
}

2
test/tint/expressions/binary/sub/mat3x3-mat3x3/f32.wgsl.expected.wgsl
View File

@ -1,6 +1,6 @@
@compute @workgroup_size(1)
fn f() {
let a = mat3x3<f32>(vec3<f32>(1.0, 2.0, 3.0), vec3<f32>(4.0, 5.0, 6.0), vec3<f32>(7.0, 8.0, 9.0));
let b = mat3x3<f32>(vec3<f32>(-1.0, -2.0, -3.0), vec3<f32>(-4.0, -5.0, -6.0), vec3<f32>(-7.0, -8.0, -9.0));
let b = mat3x3<f32>(vec3<f32>(-(1.0), -(2.0), -(3.0)), vec3<f32>(-(4.0), -(5.0), -(6.0)), vec3<f32>(-(7.0), -(8.0), -(9.0)));
let r : mat3x3<f32> = (a - b);
}

2
test/tint/expressions/bitcast/scalar/i32min-u32.wgsl.expected.wgsl
View File

@ -1,4 +1,4 @@
@compute @workgroup_size(1)
fn f() {
let b : u32 = bitcast<u32>(-2147483648);
let b : u32 = bitcast<u32>(-(2147483648));
}

4
test/tint/expressions/literals/intmin.wgsl.expected.wgsl
View File

@ -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;
}

8
test/tint/samples/compute_boids.wgsl.expected.wgsl
View File

@ -77,17 +77,17 @@ fn comp_main(@builtin(global_invocation_id) gl_GlobalInvocationID : vec3<u32>) {
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;

2
test/tint/samples/triangle.wgsl.expected.wgsl
View File

@ -1,4 +1,4 @@
const pos = array<vec2<f32>, 3>(vec2(0.0, 0.5), vec2(-0.5, -0.5), vec2(0.5, -0.5));
const pos = array<vec2<f32>, 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<f32> {