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

tint: Rename float / int literal tokens 

Rename:
• kFloatFLiteral -> kFloatLiteral_F
• kIntILiteral   -> kIntLiteral_I
• kIntULiteral   -> kIntLiteral_U

As suggested in review:
https://dawn-review.googlesource.com/c/dawn/+/89031/comments/b37253a3_e830b482

Bug: tint:1504
Change-Id: I4120f2904d8614152d4c804c226c9710f2ef8653
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/89661
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
This commit is contained in:
Ben Clayton 2022-05-10 22:26:04 +00:00 committed by Dawn LUCI CQ
parent 508e4a5a82
commit 824e824709
6 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -406,7 +406,7 @@ Token Lexer::try_float() {
case LimitCheck::kTooLarge: case LimitCheck::kTooLarge:
return {Token::Type::kError, source, "value too large for f32"}; return {Token::Type::kError, source, "value too large for f32"};
default: default:
return {Token::Type::kFloatFLiteral, source, value}; return {Token::Type::kFloatLiteral_F, source, value};
} }
} }
@ -715,7 +715,7 @@ Token Lexer::try_hex_float() {
float result_f32; float result_f32;
std::memcpy(&result_f32, &result_u32, sizeof(result_f32)); std::memcpy(&result_f32, &result_u32, sizeof(result_f32));
double result_f64 = static_cast<double>(result_f32); double result_f64 = static_cast<double>(result_f32);
return {has_f_suffix ? Token::Type::kFloatFLiteral : Token::Type::kFloatLiteral, source, return {has_f_suffix ? Token::Type::kFloatLiteral_F : Token::Type::kFloatLiteral, source,
result_f64}; result_f64};
} }
@ -731,7 +731,7 @@ Token Lexer::build_token_from_int_if_possible(Source source, size_t start, int32
default: default:
advance(1); advance(1);
end_source(source); end_source(source);
return {Token::Type::kIntULiteral, source, res}; return {Token::Type::kIntLiteral_U, source, res};
} }
} }
@ -746,7 +746,7 @@ Token Lexer::build_token_from_int_if_possible(Source source, size_t start, int32
} }
advance(1); advance(1);
end_source(source); end_source(source);
return {Token::Type::kIntILiteral, source, res}; return {Token::Type::kIntLiteral_I, source, res};
} }
// TODO(crbug.com/tint/1504): Properly support abstract int: // TODO(crbug.com/tint/1504): Properly support abstract int:

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

@ -317,7 +317,7 @@ TEST_P(FloatTest, Parse) {
auto t = l.next(); auto t = l.next();
if (std::string(params.input).back() == 'f') { if (std::string(params.input).back() == 'f') {
EXPECT_TRUE(t.Is(Token::Type::kFloatFLiteral)); EXPECT_TRUE(t.Is(Token::Type::kFloatLiteral_F));
} else { } else {
EXPECT_TRUE(t.Is(Token::Type::kFloatLiteral)); EXPECT_TRUE(t.Is(Token::Type::kFloatLiteral));
} }
@ -611,7 +611,7 @@ TEST_P(IntegerTest_HexSigned, ISuffix) {
Lexer l(&file); Lexer l(&file);
auto t = l.next(); auto t = l.next();
EXPECT_TRUE(t.Is(Token::Type::kIntILiteral)); EXPECT_TRUE(t.Is(Token::Type::kIntLiteral_I));
EXPECT_EQ(t.source().range.begin.line, 1u); EXPECT_EQ(t.source().range.begin.line, 1u);
EXPECT_EQ(t.source().range.begin.column, 1u); EXPECT_EQ(t.source().range.begin.column, 1u);
EXPECT_EQ(t.source().range.end.line, 1u); EXPECT_EQ(t.source().range.end.line, 1u);
@ -727,7 +727,7 @@ TEST_P(IntegerTest_HexUnsigned, Matches) {
Lexer l(&file); Lexer l(&file);
auto t = l.next(); auto t = l.next();
EXPECT_TRUE(t.Is(Token::Type::kIntULiteral)); EXPECT_TRUE(t.Is(Token::Type::kIntLiteral_U));
EXPECT_EQ(t.source().range.begin.line, 1u); EXPECT_EQ(t.source().range.begin.line, 1u);
EXPECT_EQ(t.source().range.begin.column, 1u); EXPECT_EQ(t.source().range.begin.column, 1u);
EXPECT_EQ(t.source().range.end.line, 1u); EXPECT_EQ(t.source().range.end.line, 1u);
@ -770,7 +770,7 @@ TEST_P(IntegerTest_Unsigned, Matches) {
Lexer l(&file); Lexer l(&file);
auto t = l.next(); auto t = l.next();
EXPECT_TRUE(t.Is(Token::Type::kIntULiteral)); EXPECT_TRUE(t.Is(Token::Type::kIntLiteral_U));
EXPECT_EQ(t.to_i64(), params.result); EXPECT_EQ(t.to_i64(), params.result);
EXPECT_EQ(t.source().range.begin.line, 1u); EXPECT_EQ(t.source().range.begin.line, 1u);
EXPECT_EQ(t.source().range.begin.column, 1u); EXPECT_EQ(t.source().range.begin.column, 1u);
@ -839,8 +839,8 @@ TEST_P(IntegerTest_Invalid, Parses) {
auto t = l.next(); auto t = l.next();
EXPECT_FALSE(t.Is(Token::Type::kIntLiteral)); EXPECT_FALSE(t.Is(Token::Type::kIntLiteral));
EXPECT_FALSE(t.Is(Token::Type::kIntULiteral)); EXPECT_FALSE(t.Is(Token::Type::kIntLiteral_U));
EXPECT_FALSE(t.Is(Token::Type::kIntILiteral)); EXPECT_FALSE(t.Is(Token::Type::kIntLiteral_I));
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
LexerTest, LexerTest,

8
src/tint/reader/wgsl/parser_impl.cc
View File

@ -2781,11 +2781,11 @@ Maybe<const ast::LiteralExpression*> ParserImpl::const_literal() {
return create<ast::IntLiteralExpression>(t.source(), t.to_i64(), return create<ast::IntLiteralExpression>(t.source(), t.to_i64(),
ast::IntLiteralExpression::Suffix::kNone); ast::IntLiteralExpression::Suffix::kNone);
} }
if (match(Token::Type::kIntILiteral)) { if (match(Token::Type::kIntLiteral_I)) {
return create<ast::IntLiteralExpression>(t.source(), t.to_i64(), return create<ast::IntLiteralExpression>(t.source(), t.to_i64(),
ast::IntLiteralExpression::Suffix::kI); ast::IntLiteralExpression::Suffix::kI);
} }
if (match(Token::Type::kIntULiteral)) { if (match(Token::Type::kIntLiteral_U)) {
return create<ast::IntLiteralExpression>(t.source(), t.to_i64(), return create<ast::IntLiteralExpression>(t.source(), t.to_i64(),
ast::IntLiteralExpression::Suffix::kU); ast::IntLiteralExpression::Suffix::kU);
} }
@ -2793,7 +2793,7 @@ Maybe<const ast::LiteralExpression*> ParserImpl::const_literal() {
return create<ast::FloatLiteralExpression>(t.source(), t.to_f64(), return create<ast::FloatLiteralExpression>(t.source(), t.to_f64(),
ast::FloatLiteralExpression::Suffix::kNone); ast::FloatLiteralExpression::Suffix::kNone);
} }
if (match(Token::Type::kFloatFLiteral)) { if (match(Token::Type::kFloatLiteral_F)) {
return create<ast::FloatLiteralExpression>(t.source(), t.to_f64(), return create<ast::FloatLiteralExpression>(t.source(), t.to_f64(),
ast::FloatLiteralExpression::Suffix::kF); ast::FloatLiteralExpression::Suffix::kF);
} }
@ -3131,7 +3131,7 @@ bool ParserImpl::expect(std::string_view use, Token::Type tok) {
Expect<int32_t> ParserImpl::expect_sint(std::string_view use) { Expect<int32_t> ParserImpl::expect_sint(std::string_view use) {
auto t = peek(); auto t = peek();
if (!t.Is(Token::Type::kIntLiteral) && !t.Is(Token::Type::kIntILiteral)) { if (!t.Is(Token::Type::kIntLiteral) && !t.Is(Token::Type::kIntLiteral_I)) {
return add_error(t.source(), "expected signed integer literal", use); return add_error(t.source(), "expected signed integer literal", use);
} }

12
src/tint/reader/wgsl/token.cc
View File

@ -27,13 +27,13 @@ std::string_view Token::TypeToName(Type type) {
return "identifier"; return "identifier";
case Token::Type::kFloatLiteral: case Token::Type::kFloatLiteral:
return "abstract float literal"; return "abstract float literal";
case Token::Type::kFloatFLiteral: case Token::Type::kFloatLiteral_F:
return "'f'-suffixed float literal"; return "'f'-suffixed float literal";
case Token::Type::kIntLiteral: case Token::Type::kIntLiteral:
return "abstract integer literal"; return "abstract integer literal";
case Token::Type::kIntILiteral: case Token::Type::kIntLiteral_I:
return "'i'-suffixed integer literal"; return "'i'-suffixed integer literal";
case Token::Type::kIntULiteral: case Token::Type::kIntLiteral_U:
return "'u'-suffixed integer literal"; return "'u'-suffixed integer literal";
case Token::Type::kUninitialized: case Token::Type::kUninitialized:
return "uninitialized"; return "uninitialized";
@ -307,13 +307,13 @@ std::string Token::to_str() const {
switch (type_) { switch (type_) {
case Type::kFloatLiteral: case Type::kFloatLiteral:
return std::to_string(std::get<double>(value_)); return std::to_string(std::get<double>(value_));
case Type::kFloatFLiteral: case Type::kFloatLiteral_F:
return std::to_string(std::get<double>(value_)) + "f"; return std::to_string(std::get<double>(value_)) + "f";
case Type::kIntLiteral: case Type::kIntLiteral:
return std::to_string(std::get<int64_t>(value_)); return std::to_string(std::get<int64_t>(value_));
case Type::kIntILiteral: case Type::kIntLiteral_I:
return std::to_string(std::get<int64_t>(value_)) + "i"; return std::to_string(std::get<int64_t>(value_)) + "i";
case Type::kIntULiteral: case Type::kIntLiteral_U:
return std::to_string(std::get<int64_t>(value_)) + "u"; return std::to_string(std::get<int64_t>(value_)) + "u";
case Type::kIdentifier: case Type::kIdentifier:
case Type::kError: case Type::kError:

12
src/tint/reader/wgsl/token.h
View File

@ -41,13 +41,13 @@ class Token {
/// A float literal with no suffix /// A float literal with no suffix
kFloatLiteral, kFloatLiteral,
/// A float literal with an 'f' suffix /// A float literal with an 'f' suffix
kFloatFLiteral, kFloatLiteral_F,
/// An integer literal with no suffix /// An integer literal with no suffix
kIntLiteral, kIntLiteral,
/// An integer literal with an 'i' suffix /// An integer literal with an 'i' suffix
kIntILiteral, kIntLiteral_I,
/// An integer literal with a 'u' suffix /// An integer literal with a 'u' suffix
kIntULiteral, kIntLiteral_U,
/// A '&' /// A '&'
kAnd, kAnd,
@ -342,9 +342,9 @@ class Token {
bool IsIdentifier() const { return type_ == Type::kIdentifier; } bool IsIdentifier() const { return type_ == Type::kIdentifier; }
/// @returns true if the token is a literal /// @returns true if the token is a literal
bool IsLiteral() const { bool IsLiteral() const {
return type_ == Type::kIntLiteral || type_ == Type::kIntILiteral || return type_ == Type::kIntLiteral || type_ == Type::kIntLiteral_I ||
type_ == Type::kIntULiteral || type_ == Type::kFalse || type_ == Type::kTrue || type_ == Type::kIntLiteral_U || type_ == Type::kFalse || type_ == Type::kTrue ||
type_ == Type::kFloatLiteral || type_ == Type::kFloatFLiteral; type_ == Type::kFloatLiteral || type_ == Type::kFloatLiteral_F;
} }
/// @returns true if token is a 'matNxM' /// @returns true if token is a 'matNxM'
bool IsMatrix() const { bool IsMatrix() const {

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

@ -28,40 +28,40 @@ using ::testing::StartsWith;
using TokenTest = testing::Test; using TokenTest = testing::Test;
TEST_F(TokenTest, ReturnsF64) { TEST_F(TokenTest, ReturnsF64) {
Token t1(Token::Type::kFloatFLiteral, Source{}, -2.345); Token t1(Token::Type::kFloatLiteral_F, Source{}, -2.345);
EXPECT_EQ(t1.to_f64(), -2.345); EXPECT_EQ(t1.to_f64(), -2.345);
Token t2(Token::Type::kFloatFLiteral, Source{}, 2.345); Token t2(Token::Type::kFloatLiteral_F, Source{}, 2.345);
EXPECT_EQ(t2.to_f64(), 2.345); EXPECT_EQ(t2.to_f64(), 2.345);
} }
TEST_F(TokenTest, ReturnsI32) { TEST_F(TokenTest, ReturnsI32) {
Token t1(Token::Type::kIntILiteral, Source{}, static_cast<int64_t>(-2345)); Token t1(Token::Type::kIntLiteral_I, Source{}, static_cast<int64_t>(-2345));
EXPECT_EQ(t1.to_i64(), -2345); EXPECT_EQ(t1.to_i64(), -2345);
Token t2(Token::Type::kIntILiteral, Source{}, static_cast<int64_t>(2345)); Token t2(Token::Type::kIntLiteral_I, Source{}, static_cast<int64_t>(2345));
EXPECT_EQ(t2.to_i64(), 2345); EXPECT_EQ(t2.to_i64(), 2345);
} }
TEST_F(TokenTest, HandlesMaxI32) { TEST_F(TokenTest, HandlesMaxI32) {
Token t1(Token::Type::kIntILiteral, Source{}, Token t1(Token::Type::kIntLiteral_I, Source{},
static_cast<int64_t>(std::numeric_limits<int32_t>::max())); static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
EXPECT_EQ(t1.to_i64(), std::numeric_limits<int32_t>::max()); EXPECT_EQ(t1.to_i64(), std::numeric_limits<int32_t>::max());
} }
TEST_F(TokenTest, HandlesMinI32) { TEST_F(TokenTest, HandlesMinI32) {
Token t1(Token::Type::kIntILiteral, Source{}, Token t1(Token::Type::kIntLiteral_I, Source{},
static_cast<int64_t>(std::numeric_limits<int32_t>::min())); static_cast<int64_t>(std::numeric_limits<int32_t>::min()));
EXPECT_EQ(t1.to_i64(), std::numeric_limits<int32_t>::min()); EXPECT_EQ(t1.to_i64(), std::numeric_limits<int32_t>::min());
} }
TEST_F(TokenTest, ReturnsU32) { TEST_F(TokenTest, ReturnsU32) {
Token t2(Token::Type::kIntULiteral, Source{}, static_cast<int64_t>(2345u)); Token t2(Token::Type::kIntLiteral_U, Source{}, static_cast<int64_t>(2345u));
EXPECT_EQ(t2.to_i64(), 2345u); EXPECT_EQ(t2.to_i64(), 2345u);
} }
TEST_F(TokenTest, ReturnsMaxU32) { TEST_F(TokenTest, ReturnsMaxU32) {
Token t1(Token::Type::kIntULiteral, Source{}, Token t1(Token::Type::kIntLiteral_U, Source{},
static_cast<int64_t>(std::numeric_limits<uint32_t>::max())); static_cast<int64_t>(std::numeric_limits<uint32_t>::max()));
EXPECT_EQ(t1.to_i64(), std::numeric_limits<uint32_t>::max()); EXPECT_EQ(t1.to_i64(), std::numeric_limits<uint32_t>::max());
} }
@ -83,11 +83,11 @@ TEST_F(TokenTest, ToStr) {
int64_t i = 123; int64_t i = 123;
EXPECT_THAT(Token(Token::Type::kFloatLiteral, Source{}, d).to_str(), StartsWith("123")); EXPECT_THAT(Token(Token::Type::kFloatLiteral, Source{}, d).to_str(), StartsWith("123"));
EXPECT_THAT(Token(Token::Type::kFloatLiteral, Source{}, d).to_str(), Not(EndsWith("f"))); EXPECT_THAT(Token(Token::Type::kFloatLiteral, Source{}, d).to_str(), Not(EndsWith("f")));
EXPECT_THAT(Token(Token::Type::kFloatFLiteral, Source{}, d).to_str(), StartsWith("123")); EXPECT_THAT(Token(Token::Type::kFloatLiteral_F, Source{}, d).to_str(), StartsWith("123"));
EXPECT_THAT(Token(Token::Type::kFloatFLiteral, Source{}, d).to_str(), EndsWith("f")); EXPECT_THAT(Token(Token::Type::kFloatLiteral_F, Source{}, d).to_str(), EndsWith("f"));
EXPECT_EQ(Token(Token::Type::kIntLiteral, Source{}, i).to_str(), "123"); EXPECT_EQ(Token(Token::Type::kIntLiteral, Source{}, i).to_str(), "123");
EXPECT_EQ(Token(Token::Type::kIntILiteral, Source{}, i).to_str(), "123i"); EXPECT_EQ(Token(Token::Type::kIntLiteral_I, Source{}, i).to_str(), "123i");
EXPECT_EQ(Token(Token::Type::kIntULiteral, Source{}, i).to_str(), "123u"); EXPECT_EQ(Token(Token::Type::kIntLiteral_U, Source{}, i).to_str(), "123u");
EXPECT_EQ(Token(Token::Type::kIdentifier, Source{}, "blah").to_str(), "blah"); EXPECT_EQ(Token(Token::Type::kIdentifier, Source{}, "blah").to_str(), "blah");
EXPECT_EQ(Token(Token::Type::kError, Source{}, "blah").to_str(), "blah"); EXPECT_EQ(Token(Token::Type::kError, Source{}, "blah").to_str(), "blah");
} }