Simplify UTF-16 silliness in canonicalize_path (Windows)

On Windows, replace a UTF-16-to-UTF-8 conversion with a UTF-8 code unit
count. This removes several allocations in canonicalize_path's
constructor.

I did not measure the performance impact of this change.

Holistically, the algorithm used for canonicalize_path::parent and
canonicalize_path_result::drop_missing_components is pretty bad in terms
of performance. I don't plan on fixing the algorithm any time soon
though.

Author: strager

src/file-canonical.cpp

@@ -122,9 +122,7 @@ canonical_path::canonical_path(std::string &&path) : path_(std::move(path)) {
     HRESULT result = ::PathCchRemoveFileSpec(wpath->data(), wpath->size() + 1);
     switch (result) {
     case S_OK:
-      // TODO(strager): Avoid allocating just to count UTF-8 code units.
-      this->path_lengths_.push_back(
-          std::filesystem::path(wpath->c_str()).u8string().size());
+      this->path_lengths_.push_back(count_utf_8_code_units(wpath->c_str()));
       break;
     case S_FALSE:
       // Path is a root path already.

src/quick-lint-js/utf-16.h

@@ -6,6 +6,7 @@
 
 #include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace quick_lint_js {
@@ -29,6 +30,11 @@ class mbargv {
 
 std::optional<std::wstring> mbstring_to_wstring(const char *mbstring);
 #endif
+
+std::size_t count_utf_8_code_units(std::u16string_view) noexcept;
+#if defined(_WIN32)
+std::size_t count_utf_8_code_units(std::wstring_view) noexcept;
+#endif
 }
 #endif
 

src/utf-16.cpp

@@ -9,6 +9,7 @@
 #include <quick-lint-js/narrow-cast.h>
 #include <quick-lint-js/utf-16.h>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #if defined(_WIN32)
@@ -101,6 +102,31 @@ std::optional<std::wstring> mbstring_to_wstring(const char *mbstring) {
   return wstring;
 }
 #endif
+
+std::size_t count_utf_8_code_units(std::u16string_view utf_16) noexcept {
+  std::size_t count = 0;
+  for (char16_t c : utf_16) {
+    if (c < 0x0080) {
+      count += 1;
+    } else if (c < 0x0800) {
+      count += 2;
+    } else if (0xd800 <= c && c <= 0xdfff) {
+      // Part of a surrogate pair.
+      count += 2;
+    } else {
+      count += 3;
+    }
+  }
+  return count;
+}
+
+#if defined(_WIN32)
+std::size_t count_utf_8_code_units(std::wstring_view utf_16) noexcept {
+  static_assert(sizeof(char16_t) == sizeof(wchar_t));
+  return count_utf_8_code_units(std::u16string_view(
+      reinterpret_cast<const char16_t *>(utf_16.data()), utf_16.size()));
+}
+#endif
 }
 
 // quick-lint-js finds bugs in JavaScript programs.

test/test-utf-16.cpp

@@ -4,8 +4,12 @@
 #include <gtest/gtest.h>
 #include <quick-lint-js/narrow-cast.h>
 #include <quick-lint-js/utf-16.h>
+#include <string_view>
+
+using namespace std::literals::string_view_literals;
 
 namespace quick_lint_js {
+namespace {
 #if defined(_WIN32)
 TEST(test_utf_16_windows, mbargv) {
   std::vector<wchar_t*> argv;
@@ -34,6 +38,35 @@ TEST(test_utf_16_windows, mbstring_to_wstring) {
   }
 }
 #endif
+
+TEST(test_count_utf_8_code_units_in_utf_16, empty_string) {
+  EXPECT_EQ(count_utf_8_code_units(u""sv), 0);
+}
+
+TEST(test_count_utf_8_code_units_in_utf_16, ascii) {
+  EXPECT_EQ(count_utf_8_code_units(u"abc 123"sv), 7);
+  EXPECT_EQ(count_utf_8_code_units(u"\u007f"sv), 1);
+  EXPECT_EQ(count_utf_8_code_units(u"\u0000"sv), 1);
+}
+
+TEST(test_count_utf_8_code_units_in_utf_16, 2_byte_utf_8) {
+  EXPECT_EQ(count_utf_8_code_units(u"\u0080"sv), 2);
+  EXPECT_EQ(count_utf_8_code_units(u"\u07ff"sv), 2);
+}
+
+TEST(test_count_utf_8_code_units_in_utf_16, 3_byte_utf_8) {
+  EXPECT_EQ(count_utf_8_code_units(u"\u0800"sv), 3);
+  EXPECT_EQ(count_utf_8_code_units(u"\uffff"sv), 3);
+}
+
+TEST(test_count_utf_8_code_units_in_utf_16, surrogate_pair) {
+  EXPECT_EQ(count_utf_8_code_units(u"\U00010437"sv), 4) << "D801 DC37";
+  EXPECT_EQ(count_utf_8_code_units(u"\U00024B62"sv), 4) << "D852 DF62";
+}
+
+// TODO(strager): How should count_utf_8_code_units behave with invalid UTF-16
+// (e.g. incomplete surrogate pair)?
+}
 }
 
 // quick-lint-js finds bugs in JavaScript programs.