[Parser][NFC] Small code cleanups (#4729)

Apply cleanups suggested by aheejin in post-merge code review of previous
parser PRs.

6 files changed, 203 insertions, 200 deletions

diff --git a/src/wasm/wasm-io.cpp b/src/wasm/wasm-io.cpp
index 55892975b..90f267e9b 100644
--- a/src/wasm/wasm-io.cpp
+++ b/src/wasm/wasm-io.cpp
@@ -24,12 +24,12 @@
 // binary.
 //
 
+#include "wasm-io.h"
 #include "support/debug.h"
 #include "wasm-binary.h"
 #include "wasm-s-parser.h"
 #include "wat-parser.h"
 
-#include "wasm-io.h"
 
 namespace wasm {
 
diff --git a/src/wasm/wat-lexer.cpp b/src/wasm/wat-lexer.cpp
index 0d1dc2794..c7959295c 100644
--- a/src/wasm/wat-lexer.cpp
+++ b/src/wasm/wat-lexer.cpp
@@ -942,7 +942,7 @@ void Lexer::lexToken() {
   curr = {tok};
 }
 
-TextPos Lexer::position(const char* c) {
+TextPos Lexer::position(const char* c) const {
   assert(size_t(c - buffer.data()) < buffer.size());
   TextPos pos{1, 0};
   for (const char* p = buffer.data(); p != c; ++p) {
diff --git a/src/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp
index aafb66019..caeccfd76 100644
--- a/src/wasm/wat-parser.cpp
+++ b/src/wasm/wat-parser.cpp
@@ -32,11 +32,11 @@
 // definitions. This phase establishes the indices and names of each module
 // element so that subsequent phases can look them up.
 //
-// The second phase, not yet implemented, parses type definitions to construct
-// the types used in the module. This has to be its own phase because we have no
-// way to refer to a type before it has been built along with all the other
-// types, unlike for other module elements that can be referred to by name
-// before their definitions have been parsed.
+// The second phase parses type definitions to construct the types used in the
+// module. This has to be its own phase because we have no way to refer to a
+// type before it has been built along with all the other types, unlike for
+// other module elements that can be referred to by name before their
+// definitions have been parsed.
 //
 // The third phase, not yet implemented, further parses and constructs types
 // implicitly defined by type uses in functions, blocks, and call_indirect
@@ -89,7 +89,7 @@ struct ParseInput {
     lexer.setIndex(index);
   }
 
-  bool empty() { return lexer == lexer.end(); }
+  bool empty() { return lexer.empty(); }
 
   std::optional<Token> peek() {
     if (!empty()) {
diff --git a/src/wat-lexer.h b/src/wat-lexer.h
index 30aa1e036..b41cbd8c1 100644
--- a/src/wat-lexer.h
+++ b/src/wat-lexer.h
@@ -166,7 +166,7 @@ public:
 
   Lexer(std::string_view buffer) : buffer(buffer) { setIndex(0); }
 
-  size_t getIndex() { return index; }
+  size_t getIndex() const { return index; }
 
   void setIndex(size_t i) {
     index = i;
@@ -206,12 +206,16 @@ public:
 
   Lexer begin() { return *this; }
 
-  Lexer end() { return Lexer(); }
+  Lexer end() const { return Lexer(); }
 
-  TextPos position(const char* c);
-  TextPos position(size_t i) { return position(buffer.data() + i); }
-  TextPos position(std::string_view span) { return position(span.data()); }
-  TextPos position(Token tok) { return position(tok.span); }
+  bool empty() const { return *this == end(); }
+
+  TextPos position(const char* c) const;
+  TextPos position(size_t i) const { return position(buffer.data() + i); }
+  TextPos position(std::string_view span) const {
+    return position(span.data());
+  }
+  TextPos position(Token tok) const { return position(tok.span); }
 
 private:
   void skipSpace();
diff --git a/src/wat-parser.h b/src/wat-parser.h
index 4bb9b62c8..7f92de9e4 100644
--- a/src/wat-parser.h
+++ b/src/wat-parser.h
@@ -17,7 +17,6 @@
 #ifndef wasm_wat_parser_h
 #define wasm_wat_parser_h
 
-#include <optional>
 #include <string_view>
 
 #include "wasm.h"
@@ -37,7 +36,7 @@ template<typename T = Ok> struct Result {
 
   Result(Result<T>& other) = default;
   Result(const Err& e) : val(std::in_place_type<Err>, e) {}
-  Result(Err&& e) : val(std::in_place_type<Err>, e) {}
+  Result(Err&& e) : val(std::in_place_type<Err>, std::move(e)) {}
   template<typename U = T>
   Result(U&& u) : val(std::in_place_type<T>, std::forward<U>(u)) {}
 
diff --git a/test/gtest/wat-lexer.cpp b/test/gtest/wat-lexer.cpp
index 0f83127c8..0820f4561 100644
--- a/test/gtest/wat-lexer.cpp
+++ b/test/gtest/wat-lexer.cpp
@@ -123,127 +123,127 @@ TEST(LexerTest, LexParens) {
 TEST(LexerTest, LexInt) {
   {
     Lexer lexer("0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0"sv, IntTok{0, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0"sv, IntTok{0, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0"sv, IntTok{0, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"1"sv, IntTok{1, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+1"sv, IntTok{1, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-1"sv, IntTok{-1ull, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0010"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0010"sv, IntTok{10, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0010"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0010"sv, IntTok{10, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0010"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0010"sv, IntTok{-10ull, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("9999"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"9999"sv, IntTok{9999, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+9999"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+9999"sv, IntTok{9999, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-9999"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-9999"sv, IntTok{-9999ull, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("12_34"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"12_34"sv, IntTok{1234, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("1_2_3_4"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"1_2_3_4"sv, IntTok{1234, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("_1234"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("1234_"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("12__34"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("12cd56"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("18446744073709551615"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"18446744073709551615"sv, IntTok{-1ull, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     // 64-bit unsigned overflow!
     Lexer lexer("18446744073709551616"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"18446744073709551616"sv,
                    FloatTok{{}, 18446744073709551616.}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+9223372036854775807"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+9223372036854775807"sv, IntTok{INT64_MAX, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+9223372036854775808"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+9223372036854775808"sv,
                    IntTok{uint64_t(INT64_MAX) + 1, Pos}};
     ;
@@ -251,13 +251,13 @@ TEST(LexerTest, LexInt) {
   }
   {
     Lexer lexer("-9223372036854775808"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-9223372036854775808"sv, IntTok{uint64_t(INT64_MIN), Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-9223372036854775809"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-9223372036854775809"sv,
                    IntTok{uint64_t(INT64_MIN) - 1, Neg}};
     EXPECT_EQ(*lexer, expected);
@@ -267,118 +267,118 @@ TEST(LexerTest, LexInt) {
 TEST(LexerTest, LexHexInt) {
   {
     Lexer lexer("0x0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x0"sv, IntTok{0, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0x0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0x0"sv, IntTok{0, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0x0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0x0"sv, IntTok{0, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x1"sv, IntTok{1, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0x1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0x1"sv, IntTok{1, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0x1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0x1"sv, IntTok{-1ull, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x0010"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x0010"sv, IntTok{16, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0x0010"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0x0010"sv, IntTok{16, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0x0010"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0x0010"sv, IntTok{-16ull, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0xabcdef"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0xabcdef"sv, IntTok{0xabcdef, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0xABCDEF"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0xABCDEF"sv, IntTok{0xabcdef, Pos}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0xAbCdEf"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0xAbCdEf"sv, IntTok{-0xabcdefull, Neg}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x12_34"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x12_34"sv, IntTok{0x1234, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x1_2_3_4"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x1_2_3_4"sv, IntTok{0x1234, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("_0x1234"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x_1234"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x1234_"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x12__34"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0xg"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x120x34"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
 }
 
 TEST(LexerTest, ClassifyInt) {
   {
     Lexer lexer("0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -402,7 +402,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -424,7 +424,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("-0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -446,7 +446,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("0x7fff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -468,7 +468,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("0x8000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -489,7 +489,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0x7fff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -509,7 +509,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0x8000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -527,7 +527,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("-0x8000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -547,7 +547,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("-0x8000_0001"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -565,7 +565,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("0xffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -586,7 +586,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("0x1_0000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -605,7 +605,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0xffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -623,7 +623,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0x1_0000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -641,7 +641,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("0x7fff_ffff_ffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -660,7 +660,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0x7fff_ffff_ffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -678,7 +678,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("-0x8000_0000_0000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     ASSERT_TRUE(lexer->getS64());
@@ -696,7 +696,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("0xffff_ffff_ffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getU64());
     EXPECT_FALSE(lexer->getS64());
@@ -714,7 +714,7 @@ TEST(LexerTest, ClassifyInt) {
   }
   {
     Lexer lexer("+0xffff_ffff_ffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     EXPECT_FALSE(lexer->getU64());
     EXPECT_FALSE(lexer->getS64());
@@ -733,361 +733,361 @@ TEST(LexerTest, ClassifyInt) {
 TEST(LexerTest, LexFloat) {
   {
     Lexer lexer("42"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42"sv, IntTok{42, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42."sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42."sv, FloatTok{{}, 42.}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.5"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.5"sv, FloatTok{{}, 42.5}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42e0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42e0"sv, FloatTok{{}, 42e0}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.e1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.e1"sv, FloatTok{{}, 42.e1}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42E1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42E1"sv, FloatTok{{}, 42E1}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42e+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42e+2"sv, FloatTok{{}, 42e+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.E-02"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.E-02"sv, FloatTok{{}, 42.E-02}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.0e0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.0e0"sv, FloatTok{{}, 42.0e0}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.0E1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.0E1"sv, FloatTok{{}, 42.0E1}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.0e+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.0e+2"sv, FloatTok{{}, 42.0e+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("42.0E-2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"42.0E-2"sv, FloatTok{{}, 42.0E-2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+42.0e+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+42.0e+2"sv, FloatTok{{}, +42.0e+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-42.0e+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-42.0e+2"sv, FloatTok{{}, -42.0e+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("4_2.0_0e+0_2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"4_2.0_0e+0_2"sv, FloatTok{{}, 42.00e+02}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42.junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42.0junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42.Ejunk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42.e-junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42.e-10junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("+"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42e"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42eABC"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42e0xABC"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("+-42"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("-+42"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42e+-0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42e-+0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42p0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("42P0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
 }
 
 TEST(LexerTest, LexHexFloat) {
   {
     Lexer lexer("0x4B"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B"sv, IntTok{0x4B, NoSign}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B."sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B."sv, FloatTok{{}, 0x4Bp0}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.5"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.5"sv, FloatTok{{}, 0x4B.5p0}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4Bp0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4Bp0"sv, FloatTok{{}, 0x4Bp0}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.p1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.p1"sv, FloatTok{{}, 0x4B.p1}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4BP1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4BP1"sv, FloatTok{{}, 0x4BP1}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4Bp+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4Bp+2"sv, FloatTok{{}, 0x4Bp+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.P-02"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.P-02"sv, FloatTok{{}, 0x4B.P-02}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.0p0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.0p0"sv, FloatTok{{}, 0x4B.0p0}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.0P1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.0P1"sv, FloatTok{{}, 0x4B.0P1}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.0p+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.0p+2"sv, FloatTok{{}, 0x4B.0p+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4B.0P-2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4B.0P-2"sv, FloatTok{{}, 0x4B.0P-2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+0x4B.0p+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+0x4B.0p+2"sv, FloatTok{{}, +0x4B.0p+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-0x4B.0p+2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-0x4B.0p+2"sv, FloatTok{{}, -0x4B.0p+2}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4_2.0_0p+0_2"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"0x4_2.0_0p+0_2"sv, FloatTok{{}, 0x42.00p+02}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("0x4Bjunk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.0junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.Pjunk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.p-junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.p-10junk"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("+0x"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4Bp"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4BpABC"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4Bp0xABC"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x+0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("+-0x4B"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("-+0x4B"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4Bp+-0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4Bp-+0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.e+0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("0x4B.E-0"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
 }
 
 TEST(LexerTest, LexInfinity) {
   {
     Lexer lexer("inf"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"inf"sv, FloatTok{{}, INFINITY}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+inf"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+inf"sv, FloatTok{{}, INFINITY}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-inf"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-inf"sv, FloatTok{{}, -INFINITY}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("infjunk"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"infjunk"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("Inf"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("INF"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("infinity"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"infinity"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
@@ -1096,115 +1096,115 @@ TEST(LexerTest, LexInfinity) {
 TEST(LexerTest, LexNan) {
   {
     Lexer lexer("nan"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan"sv, FloatTok{{}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+nan"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+nan"sv, FloatTok{{}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-nan"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-nan"sv, FloatTok{{}, -NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0x01"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0x01"sv, FloatTok{{1}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("+nan:0x01"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"+nan:0x01"sv, FloatTok{{1}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("-nan:0x01"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"-nan:0x01"sv, FloatTok{{1}, -NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0x1234"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0x1234"sv, FloatTok{{0x1234}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0xf_ffff_ffff_ffff"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0xf_ffff_ffff_ffff"sv,
                    FloatTok{{0xfffffffffffff}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nanjunk"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nanjunk", KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0x"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0x"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0xjunk"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0xjunk"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:-0x1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:-0x1"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:+0x1"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:+0x1"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0x0"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0x0"sv, FloatTok{{0}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0x10_0000_0000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0x10_0000_0000_0000"sv,
                    FloatTok{{0x10000000000000}, NAN}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("nan:0x1_0000_0000_0000_0000"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"nan:0x1_0000_0000_0000_0000"sv, KeywordTok{}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("NAN"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("NaN"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
 }
 
@@ -1217,7 +1217,7 @@ TEST(LexerTest, ClassifyFloat) {
   constexpr uint32_t fnanDefault = 1u << (signif32 - 1);
   {
     Lexer lexer("340282346638528859811704183484516925440."sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     ASSERT_TRUE(lexer->getF64());
     EXPECT_TRUE(lexer->getF32());
     EXPECT_EQ(*lexer->getF64(), FLT_MAX);
@@ -1230,7 +1230,7 @@ TEST(LexerTest, ClassifyFloat) {
                 "38932894407586850845513394230458323690322294816580855933212334"
                 "8274797826204144723168738177180919299881250404026184124858368"
                 "."sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     ASSERT_TRUE(lexer->getF64());
     ASSERT_TRUE(lexer->getF32());
     EXPECT_EQ(*lexer->getF64(), DBL_MAX);
@@ -1238,7 +1238,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("nan");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getF64());
     double d = *lexer->getF64();
@@ -1258,7 +1258,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("-nan");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getF64());
     double d = *lexer->getF64();
@@ -1278,7 +1278,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("+nan");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getF64());
     double d = *lexer->getF64();
@@ -1298,7 +1298,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("nan:0x1234");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getF64());
     double d = *lexer->getF64();
@@ -1316,7 +1316,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("nan:0x7FFFFF");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getF64());
     double d = *lexer->getF64();
@@ -1334,7 +1334,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("nan:0x800000");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_TRUE(lexer->getF64());
     double d = *lexer->getF64();
@@ -1347,7 +1347,7 @@ TEST(LexerTest, ClassifyFloat) {
   }
   {
     Lexer lexer("nan:0x0");
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
 
     ASSERT_FALSE(lexer->getF64());
     ASSERT_FALSE(lexer->getF32());
@@ -1357,7 +1357,7 @@ TEST(LexerTest, ClassifyFloat) {
 TEST(LexerTest, LexIdent) {
   {
     Lexer lexer("$09azAZ!#$%&'*+-./:<=>?@\\^_`|~"sv);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{"$09azAZ!#$%&'*+-./:<=>?@\\^_`|~"sv, IdTok{}};
     EXPECT_EQ(*lexer, expected);
     EXPECT_TRUE(lexer->getID());
@@ -1365,15 +1365,15 @@ TEST(LexerTest, LexIdent) {
   }
   {
     Lexer lexer("$[]{}"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("$abc[]"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("$"sv);
-    EXPECT_EQ(lexer, lexer.end());
+    EXPECT_TRUE(lexer.empty());
   }
 }
 
@@ -1381,7 +1381,7 @@ TEST(LexerTest, LexString) {
   {
     auto pangram = "\"The quick brown fox jumps over the lazy dog\""sv;
     Lexer lexer(pangram);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{pangram, StringTok{{}}};
     EXPECT_EQ(*lexer, expected);
     EXPECT_TRUE(lexer->getString());
@@ -1391,14 +1391,14 @@ TEST(LexerTest, LexString) {
   {
     auto chars = "\"`~!@#$%^&*()_-+0123456789|,.<>/?;:'\""sv;
     Lexer lexer(chars);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{chars, StringTok{{}}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     auto escapes = "\"_\\t_\\n_\\r_\\\\_\\\"_\\'_\""sv;
     Lexer lexer(escapes);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{escapes, StringTok{{"_\t_\n_\r_\\_\"_'_"}}};
     EXPECT_EQ(*lexer, expected);
     EXPECT_TRUE(lexer->getString());
@@ -1407,7 +1407,7 @@ TEST(LexerTest, LexString) {
   {
     auto escapes = "\"_\\00_\\07_\\20_\\5A_\\7F_\\ff_\\ffff_\""sv;
     Lexer lexer(escapes);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     std::string escaped{"_\0_\7_ _Z_\x7f_\xff_\xff"
                         "ff_"sv};
     Token expected{escapes, StringTok{{escaped}}};
@@ -1417,7 +1417,7 @@ TEST(LexerTest, LexString) {
     // _$_£_€_𐍈_
     auto unicode = "\"_\\u{24}_\\u{00a3}_\\u{20AC}_\\u{10348}_\""sv;
     Lexer lexer(unicode);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     std::string escaped{"_$_\xC2\xA3_\xE2\x82\xAC_\xF0\x90\x8D\x88_"};
     Token expected{unicode, StringTok{{escaped}}};
     EXPECT_EQ(*lexer, expected);
@@ -1426,61 +1426,61 @@ TEST(LexerTest, LexString) {
     // _$_£_€_𐍈_
     auto unicode = "\"_$_\xC2\xA3_\xE2\x82\xAC_\xF0\x90\x8D\x88_\""sv;
     Lexer lexer(unicode);
-    ASSERT_NE(lexer, lexer.end());
+    ASSERT_FALSE(lexer.empty());
     Token expected{unicode, StringTok{{}}};
     EXPECT_EQ(*lexer, expected);
   }
   {
     Lexer lexer("\"unterminated"sv);
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"unescaped nul\0\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"unescaped U+19\x19\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"unescaped U+7f\x7f\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"\\ stray backslash\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"short \\f hex escape\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"bad hex \\gg\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"empty unicode \\u{}\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"not unicode \\u{abcdefg}\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"extra chars \\u{123(}\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"unpaired surrogate unicode crimes \\u{d800}\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"more surrogate unicode crimes \\u{dfff}\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
   {
     Lexer lexer("\"too big \\u{110000}\"");
-    ASSERT_EQ(lexer, lexer.end());
+    ASSERT_TRUE(lexer.empty());
   }
 }