Refactor: store error codes in 16-bit int instead of string

The diagnostic table contains error code strings (e.g. "E1234"). Each
string consumes 6 bytes in the table.

Change the code to be stored as a 16-bit integer instead, saving four
bytes per diagnostic table entry.

This commit should not change behavior.

Author: strager

src/diagnostic.cpp

@@ -1,6 +1,8 @@
 // Copyright (C) 2020  Matthew "strager" Glazar
 // See end of file for extended copyright information.
 
+#include <array>
+#include <cstdint>
 #include <cstring>
 #include <quick-lint-js/assert.h>
 #include <quick-lint-js/char8.h>
@@ -31,19 +33,38 @@
 
 namespace quick_lint_js {
 namespace {
-constexpr void strcpy(char* out, const char* in) noexcept {
-  while ((*out++ = *in++) != '\0')
-    ;
+constexpr std::uint16_t parse_code_string(const char* code_string) noexcept {
+  QLJS_CONSTEXPR_ASSERT(code_string[0] == 'E');
+  QLJS_CONSTEXPR_ASSERT('0' <= code_string[1] && code_string[1] <= '9');
+  QLJS_CONSTEXPR_ASSERT('0' <= code_string[2] && code_string[2] <= '9');
+  QLJS_CONSTEXPR_ASSERT('0' <= code_string[3] && code_string[3] <= '9');
+  QLJS_CONSTEXPR_ASSERT('0' <= code_string[4] && code_string[4] <= '9');
+  QLJS_CONSTEXPR_ASSERT(code_string[5] == '\0');
+  return static_cast<std::uint16_t>((code_string[1] - '0') * 1000 +  //
+                                    (code_string[2] - '0') * 100 +   //
+                                    (code_string[3] - '0') * 10 +    //
+                                    (code_string[4] - '0') * 1);
+}
+
+std::array<char, 5> error_code_to_string(std::uint16_t error_code) noexcept {
+  QLJS_ASSERT(error_code <= 9999);
+  return std::array<char, 5>{
+      'E',
+      static_cast<char>('0' + ((error_code / 1000) % 10)),
+      static_cast<char>('0' + ((error_code / 100) % 10)),
+      static_cast<char>('0' + ((error_code / 10) % 10)),
+      static_cast<char>('0' + ((error_code / 1) % 10)),
+  };
 }
 
 // Convert a QLJS_ERROR_TYPE user into a diagnostic_info.
 template <class Error>
 class diagnostic_info_builder {
  public:
-  constexpr explicit diagnostic_info_builder(const char* code,
+  constexpr explicit diagnostic_info_builder(const char* code_string,
                                              diagnostic_severity sev) {
     this->info_.severity = sev;
-    strcpy(this->info_.code, code);
+    this->info_.code = parse_code_string(code_string);
   }
 
   // Each of Args must be a diagnostic_message_arg_info.
@@ -144,6 +165,10 @@ const diagnostic_info& get_diagnostic_info(error_type type) noexcept {
   return all_diagnostic_infos[static_cast<std::ptrdiff_t>(type)];
 }
 
+std::array<char, 5> diagnostic_info::code_string() const noexcept {
+  return error_code_to_string(this->code);
+}
+
 QLJS_WARNING_PUSH
 // GCC thinks that all_diagnostic_infos[i].code is not null-terminated, but it
 // is.
@@ -152,7 +177,12 @@ QLJS_WARNING_IGNORE_GCC("-Wstringop-overflow")
 std::optional<error_type> error_type_from_code_slow(
     std::string_view code) noexcept {
   for (int i = 0; i < error_type_count; ++i) {
-    if (all_diagnostic_infos[i].code == code) {
+    // TODO(strager): Parse the incoming code instead of stringifying each code
+    // in the table.
+    auto diag_code_string = all_diagnostic_infos[i].code_string();
+    std::string_view diag_code_string_view(diag_code_string.data(),
+                                           diag_code_string.size());
+    if (diag_code_string_view == code) {
       return static_cast<error_type>(i);
     }
   }

src/quick-lint-js/diagnostic-formatter.h

@@ -13,6 +13,7 @@
 #include <quick-lint-js/language.h>
 #include <quick-lint-js/lex.h>
 #include <quick-lint-js/location.h>
+#include <quick-lint-js/narrow-cast.h>
 #include <quick-lint-js/translation.h>
 #include <quick-lint-js/unreachable.h>
 #include <type_traits>
@@ -143,10 +144,14 @@ class diagnostic_formatter : private diagnostic_formatter_base {
 template <class Derived>
 inline void diagnostic_formatter<Derived>::format(const diagnostic_info& info,
                                                   const void* diagnostic) {
-  this->format_message(info.code, info.severity, info.messages[0], diagnostic);
+  auto code_string = info.code_string();
+  std::string_view code_string_view(code_string.data(), code_string.size());
+
+  this->format_message(code_string_view, info.severity, info.messages[0],
+                       diagnostic);
   if (info.messages[1].format.valid()) {
-    this->format_message(info.code, diagnostic_severity::note, info.messages[1],
-                         diagnostic);
+    this->format_message(code_string_view, diagnostic_severity::note,
+                         info.messages[1], diagnostic);
   }
 }
 

src/quick-lint-js/diagnostic.h

@@ -4,6 +4,7 @@
 #ifndef QUICK_LINT_JS_DIAGNOSTIC_H
 #define QUICK_LINT_JS_DIAGNOSTIC_H
 
+#include <array>
 #include <cstddef>
 #include <cstdint>
 #include <optional>
@@ -78,7 +79,9 @@ struct diagnostic_message_info {
 };
 
 struct diagnostic_info {
-  char code[6];
+  std::array<char, 5> code_string() const noexcept;
+
+  std::uint16_t code;
   diagnostic_severity severity QLJS_WORK_AROUND_GCC_BUG_105191;
   // If we support more than two infos (i.e. more than one note), the VS Code
   // plugin needs to be updated. See NOTE(multiple notes).

test/test-diagnostic-formatter.cpp

@@ -94,7 +94,7 @@ TEST(test_diagnostic_formatter, single_span_simple_message) {
 
 TEST(test_diagnostic_formatter, diagnostic_with_single_message) {
   constexpr diagnostic_info info = {
-      .code = "E9999",
+      .code = 9999,
       .severity = diagnostic_severity::error,
       .messages =
           {
@@ -115,7 +115,7 @@ TEST(test_diagnostic_formatter, diagnostic_with_single_message) {
 
 TEST(test_diagnostic_formatter, diagnostic_with_two_messages) {
   constexpr diagnostic_info info = {
-      .code = "E9999",
+      .code = 9999,
       .severity = diagnostic_severity::error,
       .messages =
           {

test/test-diagnostic.cpp

@@ -23,7 +23,7 @@ TEST(test_diagnostic, diagnostic_info) {
   {
     const diagnostic_info& info = diagnostic_info_for_error<
         error_expected_parentheses_around_if_condition>;
-    EXPECT_EQ(info.code, "E0017"sv);
+    EXPECT_EQ(info.code, 17);
     EXPECT_EQ(info.severity, diagnostic_severity::error);
     EXPECT_STREQ(source_code_messages.translate(info.messages[0].format),
                  "if statement needs parentheses around condition");
@@ -38,7 +38,7 @@ TEST(test_diagnostic, diagnostic_info) {
   {
     const diagnostic_info& info = diagnostic_info_for_error<
         error_expected_parenthesis_around_if_condition>;
-    EXPECT_EQ(info.code, "E0018"sv);
+    EXPECT_EQ(info.code, 18);
     EXPECT_EQ(info.severity, diagnostic_severity::error);
     EXPECT_STREQ(source_code_messages.translate(info.messages[0].format),
                  "if statement is missing '{1}' around condition");
@@ -55,7 +55,7 @@ TEST(test_diagnostic, diagnostic_info) {
   {
     const diagnostic_info& info = diagnostic_info_for_error<
         error_function_call_before_declaration_in_block_scope>;
-    EXPECT_EQ(info.code, "E0077"sv);
+    EXPECT_EQ(info.code, 77);
     EXPECT_EQ(info.severity, diagnostic_severity::warning);
     EXPECT_STREQ(source_code_messages.translate(info.messages[0].format),
                  "function called before declaration in block scope: {0}");
@@ -74,7 +74,7 @@ TEST(test_diagnostic, diagnostic_info) {
   {
     const diagnostic_info& info =
         diagnostic_info_for_error<error_class_statement_not_allowed_in_body>;
-    EXPECT_EQ(info.code, "E0149"sv);
+    EXPECT_EQ(info.code, 149);
     EXPECT_EQ(info.severity, diagnostic_severity::error);
     EXPECT_STREQ(source_code_messages.translate(info.messages[0].format),
                  "missing body for {1:headlinese}");

test/test-vim-qflist-json-error-reporter.cpp

@@ -282,7 +282,7 @@ TEST_F(test_vim_qflist_json_error_reporter, use_of_undeclared_variable) {
 
 TEST(test_vim_qflist_json_error_formatter, single_span_simple_message) {
   constexpr diagnostic_info diag_info = {
-      .code = "E9999",
+      .code = 9999,
       .severity = diagnostic_severity::error,
       .messages =
           {
@@ -321,7 +321,7 @@ TEST(test_vim_qflist_json_error_formatter, message_with_note_ignores_note) {
     source_code_span world_span;
   };
   constexpr diagnostic_info diag_info = {
-      .code = "E9999",
+      .code = 9999,
       .severity = diagnostic_severity::error,
       .messages =
           {