mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-05 22:02:55 +01:00
Accessor renames on lexer (#1134)
This commit is contained in:
Jon Meow
GitHub
@@ -48,7 +48,7 @@ class LexerTest : public ::testing::Test {
|
||||
|
||||
TEST_F(LexerTest, HandlesEmptyBuffer) {
|
||||
auto buffer = Lex("");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{{TokenKind::EndOfFile()}}));
|
||||
@@ -56,7 +56,7 @@ TEST_F(LexerTest, HandlesEmptyBuffer) {
|
||||
|
||||
TEST_F(LexerTest, TracksLinesAndColumns) {
|
||||
auto buffer = Lex("\n ;;\n ;;;\n x\"foo\" \"\"\"baz\n a\n \"\"\" y");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Semi(),
|
||||
@@ -103,7 +103,7 @@ TEST_F(LexerTest, TracksLinesAndColumns) {
|
||||
|
||||
TEST_F(LexerTest, HandlesNumericLiteral) {
|
||||
auto buffer = Lex("12-578\n 1 2\n0x12_3ABC\n0b10_10_11\n1_234_567\n1.5e9");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
ASSERT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::IntegerLiteral(),
|
||||
@@ -152,21 +152,21 @@ TEST_F(LexerTest, HandlesNumericLiteral) {
|
||||
.text = "1.5e9"},
|
||||
{.kind = TokenKind::EndOfFile(), .line = 6, .column = 6},
|
||||
}));
|
||||
auto token_12 = buffer.Tokens().begin();
|
||||
auto token_12 = buffer.tokens().begin();
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_12), 12);
|
||||
auto token_578 = buffer.Tokens().begin() + 2;
|
||||
auto token_578 = buffer.tokens().begin() + 2;
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_578), 578);
|
||||
auto token_1 = buffer.Tokens().begin() + 3;
|
||||
auto token_1 = buffer.tokens().begin() + 3;
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_1), 1);
|
||||
auto token_2 = buffer.Tokens().begin() + 4;
|
||||
auto token_2 = buffer.tokens().begin() + 4;
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_2), 2);
|
||||
auto token_0x12_3abc = buffer.Tokens().begin() + 5;
|
||||
auto token_0x12_3abc = buffer.tokens().begin() + 5;
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_0x12_3abc), 0x12'3abc);
|
||||
auto token_0b10_10_11 = buffer.Tokens().begin() + 6;
|
||||
auto token_0b10_10_11 = buffer.tokens().begin() + 6;
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_0b10_10_11), 0b10'10'11);
|
||||
auto token_1_234_567 = buffer.Tokens().begin() + 7;
|
||||
auto token_1_234_567 = buffer.tokens().begin() + 7;
|
||||
EXPECT_EQ(buffer.GetIntegerLiteral(*token_1_234_567), 1'234'567);
|
||||
auto token_1_5e9 = buffer.Tokens().begin() + 8;
|
||||
auto token_1_5e9 = buffer.tokens().begin() + 8;
|
||||
auto value_1_5e9 = buffer.GetRealLiteral(*token_1_5e9);
|
||||
EXPECT_EQ(value_1_5e9.Mantissa().getZExtValue(), 15);
|
||||
EXPECT_EQ(value_1_5e9.Exponent().getSExtValue(), 8);
|
||||
@@ -175,7 +175,7 @@ TEST_F(LexerTest, HandlesNumericLiteral) {
|
||||
|
||||
TEST_F(LexerTest, HandlesInvalidNumericLiterals) {
|
||||
auto buffer = Lex("14x 15_49 0x3.5q 0x3_4.5_6 0ops");
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
ASSERT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Error(),
|
||||
@@ -224,7 +224,7 @@ TEST_F(LexerTest, SplitsNumericLiteralsProperly) {
|
||||
13._
|
||||
)";
|
||||
auto buffer = Lex(source_text);
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::IntegerLiteral(), .text = "1"},
|
||||
@@ -282,7 +282,7 @@ TEST_F(LexerTest, SplitsNumericLiteralsProperly) {
|
||||
TEST_F(LexerTest, HandlesGarbageCharacters) {
|
||||
constexpr char GarbageText[] = "$$💩-$\n$\0$12$\n\\\"\\\n\"x";
|
||||
auto buffer = Lex(llvm::StringRef(GarbageText, sizeof(GarbageText) - 1));
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
@@ -320,7 +320,7 @@ TEST_F(LexerTest, Symbols) {
|
||||
// common code, but we want to check specific patterns to verify things like
|
||||
// max-munch rule and handling of interesting symbols.
|
||||
auto buffer = Lex("<<<");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::LessLess()},
|
||||
{TokenKind::Less()},
|
||||
@@ -328,7 +328,7 @@ TEST_F(LexerTest, Symbols) {
|
||||
}));
|
||||
|
||||
buffer = Lex("<<=>>");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::LessLessEqual()},
|
||||
{TokenKind::GreaterGreater()},
|
||||
@@ -336,7 +336,7 @@ TEST_F(LexerTest, Symbols) {
|
||||
}));
|
||||
|
||||
buffer = Lex("< <=> >");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::Less()},
|
||||
{TokenKind::LessEqualGreater()},
|
||||
@@ -345,7 +345,7 @@ TEST_F(LexerTest, Symbols) {
|
||||
}));
|
||||
|
||||
buffer = Lex("\\/?@&^!");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::Backslash()},
|
||||
{TokenKind::Slash()},
|
||||
@@ -360,7 +360,7 @@ TEST_F(LexerTest, Symbols) {
|
||||
|
||||
TEST_F(LexerTest, Parens) {
|
||||
auto buffer = Lex("()");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::OpenParen()},
|
||||
{TokenKind::CloseParen()},
|
||||
@@ -368,7 +368,7 @@ TEST_F(LexerTest, Parens) {
|
||||
}));
|
||||
|
||||
buffer = Lex("((()()))");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::OpenParen()},
|
||||
{TokenKind::OpenParen()},
|
||||
@@ -384,7 +384,7 @@ TEST_F(LexerTest, Parens) {
|
||||
|
||||
TEST_F(LexerTest, CurlyBraces) {
|
||||
auto buffer = Lex("{}");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::OpenCurlyBrace()},
|
||||
{TokenKind::CloseCurlyBrace()},
|
||||
@@ -392,7 +392,7 @@ TEST_F(LexerTest, CurlyBraces) {
|
||||
}));
|
||||
|
||||
buffer = Lex("{{{}{}}}");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::OpenCurlyBrace()},
|
||||
{TokenKind::OpenCurlyBrace()},
|
||||
@@ -409,8 +409,8 @@ TEST_F(LexerTest, CurlyBraces) {
|
||||
TEST_F(LexerTest, MatchingGroups) {
|
||||
{
|
||||
TokenizedBuffer buffer = Lex("(){}");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
auto it = buffer.Tokens().begin();
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
auto it = buffer.tokens().begin();
|
||||
auto open_paren_token = *it++;
|
||||
auto close_paren_token = *it++;
|
||||
EXPECT_EQ(close_paren_token,
|
||||
@@ -425,13 +425,13 @@ TEST_F(LexerTest, MatchingGroups) {
|
||||
buffer.GetMatchedOpeningToken(close_curly_token));
|
||||
auto eof_token = *it++;
|
||||
EXPECT_EQ(buffer.GetKind(eof_token), TokenKind::EndOfFile());
|
||||
EXPECT_EQ(buffer.Tokens().end(), it);
|
||||
EXPECT_EQ(buffer.tokens().end(), it);
|
||||
}
|
||||
|
||||
{
|
||||
TokenizedBuffer buffer = Lex("({x}){(y)} {{((z))}}");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
auto it = buffer.Tokens().begin();
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
auto it = buffer.tokens().begin();
|
||||
auto open_paren_token = *it++;
|
||||
auto open_curly_token = *it++;
|
||||
ASSERT_EQ("x", buffer.GetIdentifierText(buffer.GetIdentifier(*it++)));
|
||||
@@ -488,13 +488,13 @@ TEST_F(LexerTest, MatchingGroups) {
|
||||
|
||||
auto eof_token = *it++;
|
||||
EXPECT_EQ(buffer.GetKind(eof_token), TokenKind::EndOfFile());
|
||||
EXPECT_EQ(buffer.Tokens().end(), it);
|
||||
EXPECT_EQ(buffer.tokens().end(), it);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(LexerTest, MismatchedGroups) {
|
||||
auto buffer = Lex("{");
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::OpenCurlyBrace()},
|
||||
@@ -503,14 +503,14 @@ TEST_F(LexerTest, MismatchedGroups) {
|
||||
}));
|
||||
|
||||
buffer = Lex("}");
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Error(), .text = "}"},
|
||||
{TokenKind::EndOfFile()},
|
||||
}));
|
||||
|
||||
buffer = Lex("{(}");
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
@@ -522,7 +522,7 @@ TEST_F(LexerTest, MismatchedGroups) {
|
||||
}));
|
||||
|
||||
buffer = Lex(")({)");
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
@@ -559,7 +559,7 @@ TEST_F(LexerTest, Whitespace) {
|
||||
// EOF
|
||||
false};
|
||||
int pos = 0;
|
||||
for (TokenizedBuffer::Token token : buffer.Tokens()) {
|
||||
for (TokenizedBuffer::Token token : buffer.tokens()) {
|
||||
ASSERT_LT(pos, std::size(space));
|
||||
EXPECT_THAT(buffer.HasLeadingWhitespace(token), Eq(space[pos]));
|
||||
++pos;
|
||||
@@ -571,7 +571,7 @@ TEST_F(LexerTest, Whitespace) {
|
||||
|
||||
TEST_F(LexerTest, Keywords) {
|
||||
auto buffer = Lex(" fn");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Fn(), .column = 4, .indent_column = 4},
|
||||
@@ -579,7 +579,7 @@ TEST_F(LexerTest, Keywords) {
|
||||
}));
|
||||
|
||||
buffer = Lex("and or not if else for return var break continue _");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{TokenKind::And()},
|
||||
{TokenKind::Or()},
|
||||
@@ -598,7 +598,7 @@ TEST_F(LexerTest, Keywords) {
|
||||
|
||||
TEST_F(LexerTest, Comments) {
|
||||
auto buffer = Lex(" ;\n // foo\n ;\n");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Semi(),
|
||||
@@ -613,21 +613,21 @@ TEST_F(LexerTest, Comments) {
|
||||
}));
|
||||
|
||||
buffer = Lex("// foo\n//\n// bar");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{{TokenKind::EndOfFile()}}));
|
||||
|
||||
// Make sure weird characters aren't a problem.
|
||||
buffer = Lex(" // foo#$!^?@-_💩🍫⃠ [̲̅$̲̅(̲̅ ͡° ͜ʖ ͡°̲̅)̲̅$̲̅]");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{{TokenKind::EndOfFile()}}));
|
||||
|
||||
// Make sure we can lex a comment at the end of the input.
|
||||
buffer = Lex("//");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(
|
||||
buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{{TokenKind::EndOfFile()}}));
|
||||
@@ -642,13 +642,13 @@ TEST_F(LexerTest, InvalidComments) {
|
||||
};
|
||||
for (llvm::StringLiteral testcase : testcases) {
|
||||
auto buffer = Lex(testcase);
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(LexerTest, Identifiers) {
|
||||
auto buffer = Lex(" foobar");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Identifier(),
|
||||
.column = 4,
|
||||
@@ -659,14 +659,14 @@ TEST_F(LexerTest, Identifiers) {
|
||||
|
||||
// Check different kinds of identifier character sequences.
|
||||
buffer = Lex("_foo_bar");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Identifier(), .text = "_foo_bar"},
|
||||
{TokenKind::EndOfFile()},
|
||||
}));
|
||||
|
||||
buffer = Lex("foo2bar00");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Identifier(), .text = "foo2bar00"},
|
||||
@@ -675,7 +675,7 @@ TEST_F(LexerTest, Identifiers) {
|
||||
|
||||
// Check that we can parse identifiers that start with a keyword.
|
||||
buffer = Lex("fnord");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer, HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Identifier(), .text = "fnord"},
|
||||
{TokenKind::EndOfFile()},
|
||||
@@ -683,7 +683,7 @@ TEST_F(LexerTest, Identifiers) {
|
||||
|
||||
// Check multiple identifiers with indent and interning.
|
||||
buffer = Lex(" foo;bar\nbar \n foo\tfoo");
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Identifier(),
|
||||
@@ -735,7 +735,7 @@ TEST_F(LexerTest, StringLiterals) {
|
||||
)";
|
||||
|
||||
auto buffer = Lex(testcase);
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
EXPECT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::StringLiteral(),
|
||||
@@ -811,11 +811,11 @@ TEST_F(LexerTest, InvalidStringLiterals) {
|
||||
for (llvm::StringLiteral test : invalid) {
|
||||
SCOPED_TRACE(test);
|
||||
auto buffer = Lex(test);
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
|
||||
// We should have formed at least one error token.
|
||||
bool found_error = false;
|
||||
for (TokenizedBuffer::Token token : buffer.Tokens()) {
|
||||
for (TokenizedBuffer::Token token : buffer.tokens()) {
|
||||
if (buffer.GetKind(token) == TokenKind::Error()) {
|
||||
found_error = true;
|
||||
break;
|
||||
@@ -834,7 +834,7 @@ TEST_F(LexerTest, TypeLiterals) {
|
||||
)";
|
||||
|
||||
auto buffer = Lex(testcase);
|
||||
EXPECT_FALSE(buffer.HasErrors());
|
||||
EXPECT_FALSE(buffer.has_errors());
|
||||
ASSERT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Identifier(),
|
||||
@@ -914,21 +914,21 @@ TEST_F(LexerTest, TypeLiterals) {
|
||||
{.kind = TokenKind::EndOfFile(), .line = 6, .column = 3},
|
||||
}));
|
||||
|
||||
auto token_i1 = buffer.Tokens().begin() + 1;
|
||||
auto token_i1 = buffer.tokens().begin() + 1;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_i1), 1);
|
||||
auto token_i20 = buffer.Tokens().begin() + 2;
|
||||
auto token_i20 = buffer.tokens().begin() + 2;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_i20), 20);
|
||||
auto token_i999999999999 = buffer.Tokens().begin() + 3;
|
||||
auto token_i999999999999 = buffer.tokens().begin() + 3;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_i999999999999), 999999999999ull);
|
||||
auto token_u1 = buffer.Tokens().begin() + 6;
|
||||
auto token_u1 = buffer.tokens().begin() + 6;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_u1), 1);
|
||||
auto token_u64 = buffer.Tokens().begin() + 7;
|
||||
auto token_u64 = buffer.tokens().begin() + 7;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_u64), 64);
|
||||
auto token_f32 = buffer.Tokens().begin() + 9;
|
||||
auto token_f32 = buffer.tokens().begin() + 9;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_f32), 32);
|
||||
auto token_f80 = buffer.Tokens().begin() + 10;
|
||||
auto token_f80 = buffer.tokens().begin() + 10;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_f80), 80);
|
||||
auto token_f1 = buffer.Tokens().begin() + 11;
|
||||
auto token_f1 = buffer.tokens().begin() + 11;
|
||||
EXPECT_EQ(buffer.GetTypeLiteralSize(*token_f1), 1);
|
||||
}
|
||||
|
||||
@@ -943,7 +943,7 @@ TEST_F(LexerTest, TypeLiteralTooManyDigits) {
|
||||
DiagnosticAt(1, 2),
|
||||
DiagnosticMessage(HasSubstr("Found a sequence of 10000 digits")))));
|
||||
auto buffer = Lex(code, consumer);
|
||||
EXPECT_TRUE(buffer.HasErrors());
|
||||
EXPECT_TRUE(buffer.has_errors());
|
||||
ASSERT_THAT(buffer,
|
||||
HasTokens(llvm::ArrayRef<ExpectedToken>{
|
||||
{.kind = TokenKind::Error(),
|
||||
@@ -1040,7 +1040,7 @@ auto GetAndDropLine(llvm::StringRef& text) -> std::string {
|
||||
|
||||
TEST_F(LexerTest, PrintingBasic) {
|
||||
auto buffer = Lex(";");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
std::string print_storage;
|
||||
llvm::raw_string_ostream print_stream(print_storage);
|
||||
buffer.Print(print_stream);
|
||||
@@ -1056,7 +1056,7 @@ TEST_F(LexerTest, PrintingBasic) {
|
||||
|
||||
TEST_F(LexerTest, PrintingInteger) {
|
||||
auto buffer = Lex("123");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
std::string print_storage;
|
||||
llvm::raw_string_ostream print_stream(print_storage);
|
||||
buffer.Print(print_stream);
|
||||
@@ -1071,7 +1071,7 @@ TEST_F(LexerTest, PrintingInteger) {
|
||||
|
||||
TEST_F(LexerTest, PrintingReal) {
|
||||
auto buffer = Lex("2.5");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
std::string print_storage;
|
||||
llvm::raw_string_ostream print_stream(print_storage);
|
||||
buffer.Print(print_stream);
|
||||
@@ -1088,7 +1088,7 @@ TEST_F(LexerTest, PrintingReal) {
|
||||
TEST_F(LexerTest, PrintingPadding) {
|
||||
// Test kind padding.
|
||||
auto buffer = Lex("(;foo;)");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
std::string print_storage;
|
||||
llvm::raw_string_ostream print_stream(print_storage);
|
||||
buffer.Print(print_stream);
|
||||
@@ -1118,7 +1118,7 @@ TEST_F(LexerTest, PrintingPadding) {
|
||||
TEST_F(LexerTest, PrintingPaddingDigits) {
|
||||
// Test digit padding with max values of 9, 10, and 11.
|
||||
auto buffer = Lex(";\n\n\n\n\n\n\n\n\n\n ;;");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
std::string print_storage;
|
||||
llvm::raw_string_ostream print_stream(print_storage);
|
||||
buffer.Print(print_stream);
|
||||
@@ -1145,7 +1145,7 @@ TEST_F(LexerTest, PrintingPaddingDigits) {
|
||||
TEST_F(LexerTest, PrintingAsYaml) {
|
||||
// Test that we can parse this into YAML and verify line and indent data.
|
||||
auto buffer = Lex("\n ;\n\n\n; ;\n\n\n\n\n\n\n\n\n\n\n");
|
||||
ASSERT_FALSE(buffer.HasErrors());
|
||||
ASSERT_FALSE(buffer.has_errors());
|
||||
std::string print_output;
|
||||
llvm::raw_string_ostream print_stream(print_output);
|
||||
buffer.Print(print_stream);
|
||||
|
||||
Reference in New Issue
Block a user