refactor(container): make padded_string use pointer-width sizes

I want to be more consistent with what size type our containers use. Switch
padded_string to use ptrdiff_t like bump_vector and span use.

On x86_64, this improves performance slightly:

    Benchmark                                     Time             CPU      Time Old      Time New       CPU Old       CPU New
    --------------------------------------------------------------------------------------------------------------------------
    benchmark_parse_file                       -0.0098         -0.0098       2077507       2057161       2077506       2057126
    benchmark_parse_file                       -0.0110         -0.0110       2081085       2058265       2081055       2058225
    benchmark_parse_file                       -0.0097         -0.0097       2081786       2061641       2081723       2061626
    benchmark_parse_file                       -0.0110         -0.0110       2083902       2060935       2083877       2060918
    benchmark_parse_file                       -0.0100         -0.0100       2084612       2063836       2084597       2063792
    benchmark_parse_file                       -0.0099         -0.0099       2085052       2064490       2084987       2064432
    benchmark_parse_file                       -0.0118         -0.0118       2085263       2060737       2085242       2060705
    benchmark_parse_file                       -0.0080         -0.0080       2084838       2068112       2084802       2068085
    benchmark_parse_file                       -0.0120         -0.0120       2083507       2058601       2083488       2058517
    benchmark_parse_file                       -0.0107         -0.0107       2083857       2061491       2083813       2061443
    benchmark_parse_file_pvalue                 0.0002          0.0002      U Test, Repetitions: 10 vs 10
    benchmark_parse_file_mean                  -0.0104         -0.0104       2083141       2061527       2083109       2061487
    benchmark_parse_file_median                -0.0109         -0.0109       2083880       2061213       2083845       2061181
    benchmark_parse_file_stddev                +0.3608         +0.3665          2409          3278          2402          3282
    benchmark_parse_file_cv                    +0.3750         +0.3808             0             0             0             0
    OVERALL_GEOMEAN                            -0.0104         -0.0104             0             0             0             0

Author: strager

benchmark/benchmark-utf-8.cpp

@@ -19,8 +19,8 @@ string8 repeat(string8_view s, int count) {
 void benchmark_advance_lsp_characters_in_utf_8(::benchmark::State& state,
                                                string8_view input) {
   padded_string padded_input(input);
-  int total_character_count = narrow_cast<int>(
-      count_lsp_characters_in_utf_8(&padded_input, padded_input.size()));
+  int total_character_count = narrow_cast<int>(count_lsp_characters_in_utf_8(
+      &padded_input, narrow_cast<int>(padded_input.size())));
   // Avoid count==size optimizations:
   int characters_to_count = total_character_count - 1;
 

src/quick-lint-js/container/padded-string.h

@@ -11,12 +11,14 @@
 #include <string>
 
 namespace quick_lint_js {
+using padded_string_size = std::ptrdiff_t;
+
 // Like std::string, but guaranteed to have several null bytes at the end.
 //
 // padded_string enables using SIMD instructions without extra bounds checking.
 class padded_string {
  public:
-  using size_type = int;
+  using size_type = padded_string_size;
 
   static constexpr size_type padding_size = 64;
 

src/quick-lint-js/io/file.cpp

@@ -65,30 +65,34 @@ platform_file_io_error file_too_large_error() {
 }
 
 result<void, platform_file_io_error> read_file_buffered(
-    platform_file_ref file, int buffer_size, padded_string *out_content) {
+    platform_file_ref file, padded_string_size buffer_size,
+    padded_string *out_content) {
   // TODO(strager): Use byte_buffer to avoid copying the file content every
   // iteration.
   for (;;) {
-    int size_before = out_content->size();
+    padded_string_size size_before = out_content->size();
     {
-      std::optional<int> new_size = checked_add(size_before, buffer_size);
+      std::optional<padded_string_size> new_size =
+          checked_add(size_before, buffer_size);
       if (!new_size.has_value()) {
         // TODO(strager): Should we try a small buffer size?
         return failed_result(file_too_large_error());
       }
       out_content->resize_grow_uninitialized(size_before + buffer_size);
     }
 
-    file_read_result read_result =
-        file.read(&out_content->data()[size_before], buffer_size);
+    // TODO(strager): Get rid of this narrow_cast.
+    file_read_result read_result = file.read(&out_content->data()[size_before],
+                                             narrow_cast<int>(buffer_size));
     if (!read_result.ok()) return read_result.propagate();
     if (read_result.at_end_of_file()) {
       // We read the entire file.
       out_content->resize(size_before);
       return {};
     }
-    std::optional<int> new_size =
-        checked_add(size_before, read_result.bytes_read());
+    // TODO(strager): Get rid of this narrow_cast.
+    std::optional<padded_string_size> new_size = checked_add(
+        size_before, narrow_cast<padded_string_size>(read_result.bytes_read()));
     QLJS_ASSERT(new_size.has_value());
     out_content->resize(*new_size);
   }

src/quick-lint-js/lsp/lsp-location.cpp

@@ -71,7 +71,9 @@ const char8 *lsp_locator::from_position(lsp_position position) const noexcept {
   bool line_is_ascii = this->line_is_ascii_[narrow_cast<std::size_t>(line)];
   bool is_last_line = line == number_of_lines - 1;
   if (is_last_line) {
-    offset_type line_length = this->input_.size() - line_begin_offset;
+    // TODO(strager): Get rid of this narrow_cast.
+    offset_type line_length =
+        narrow_cast<offset_type>(this->input_.size() - line_begin_offset);
     if (line_is_ascii) {
       if (character > line_length) {
         return &this->input_[this->input_.size()];

test/test-padded-string.cpp

@@ -134,8 +134,8 @@ TEST(test_padded_string, move_assigning_empty_string_copies_pointers) {
 namespace {
 void expect_null_terminated(const padded_string &s) {
   const char8 *data = s.c_str();
-  for (int i = 0; i < s.padding_size; ++i) {
-    int index = s.size() + i;
+  for (padded_string_size i = 0; i < s.padding_size; ++i) {
+    padded_string_size index = s.size() + i;
     EXPECT_EQ(data[index], u8'\0') << "index=" << index;
   }
 }

test/test-utf-8.cpp

@@ -504,7 +504,9 @@ TEST(test_advance_lsp_characters_in_utf_8,
 namespace {
 std::ptrdiff_t count_lsp_characters_in_utf_8(
     padded_string_view utf_8) noexcept {
-  return quick_lint_js::count_lsp_characters_in_utf_8(utf_8, utf_8.size());
+  // TODO(strager): Get rid of this narrow_cast.
+  return quick_lint_js::count_lsp_characters_in_utf_8(
+      utf_8, narrow_cast<int>(utf_8.size()));
 }
 
 std::ptrdiff_t count_lsp_characters_in_utf_8(
@@ -564,7 +566,10 @@ TEST(test_count_lsp_characters_in_utf_8,
            "\xed\xbf\xbf"_padded,  // U+DFFF
        }) {
     SCOPED_TRACE(input);
-    EXPECT_EQ(count_lsp_characters_in_utf_8(input, input.size()), input.size());
+    // TODO(strager): Get rid of this narrow_cast.
+    EXPECT_EQ(
+        count_lsp_characters_in_utf_8(input, narrow_cast<int>(input.size())),
+        input.size());
   }
 }
 
@@ -590,7 +595,10 @@ TEST(test_count_lsp_characters_in_utf_8,
            "\xfc\x83\xbf\xbf\xbf\xbf"_padded,  // U+03FFFFFF
        }) {
     SCOPED_TRACE(input);
-    EXPECT_EQ(count_lsp_characters_in_utf_8(input, input.size()), input.size());
+    // TODO(strager): Get rid of this narrow_cast.
+    EXPECT_EQ(
+        count_lsp_characters_in_utf_8(input, narrow_cast<int>(input.size())),
+        input.size());
   }
 }