refactor: rename error_type -> diag_type

strager · strager · commit 7755f1710416 · 2022-04-19T02:26:57.000-07:00
diff --git a/plugin/vscode/quick-lint-js/vscode-error-reporter.h b/plugin/vscode/quick-lint-js/vscode-error-reporter.h
@@ -137,7 +137,7 @@ class vscode_error_reporter final : public error_reporter {
 
   ::Napi::Array diagnostics() const { return this->diagnostics_; }
 
-  void report_impl(error_type type, void* error) override {
+  void report_impl(diag_type type, void* error) override {
     vscode_error_formatter formatter(
         /*vscode=*/this->vscode_,
         /*env=*/this->env_,
diff --git a/src/buffering-error-reporter.cpp b/src/buffering-error-reporter.cpp
@@ -29,7 +29,7 @@ struct buffering_error_reporter::impl {
 #undef QLJS_DIAG_TYPE
     };
 
-    error_type type;
+    diag_type type;
     underlying_error error;
   };
 
@@ -56,7 +56,7 @@ buffering_error_reporter &buffering_error_reporter::operator=(
 
 buffering_error_reporter::~buffering_error_reporter() = default;
 
-void buffering_error_reporter::report_impl(error_type type, void *error) {
+void buffering_error_reporter::report_impl(diag_type type, void *error) {
   static constexpr unsigned char error_sizes[] = {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format) \
   sizeof(::quick_lint_js::name),
diff --git a/src/c-api-error-reporter.cpp b/src/c-api-error-reporter.cpp
@@ -34,7 +34,7 @@ void c_api_error_reporter<Diagnostic, Locator>::reset() {
 }
 
 template <class Diagnostic, class Locator>
-void c_api_error_reporter<Diagnostic, Locator>::report_impl(error_type type,
+void c_api_error_reporter<Diagnostic, Locator>::report_impl(diag_type type,
                                                             void *error) {
   c_api_error_formatter formatter(this);
   formatter.format(get_diagnostic_info(type), error);
diff --git a/src/diagnostic.cpp b/src/diagnostic.cpp
@@ -165,7 +165,7 @@ DIAGNOSTIC_CONSTEXPR_IF_POSSIBLE const diagnostic_info
 #undef QLJS_DIAG_TYPE
 };
 
-const diagnostic_info& get_diagnostic_info(error_type type) noexcept {
+const diagnostic_info& get_diagnostic_info(diag_type type) noexcept {
   return all_diagnostic_infos[static_cast<std::ptrdiff_t>(type)];
 }
 
@@ -178,16 +178,16 @@ QLJS_WARNING_PUSH
 // is.
 QLJS_WARNING_IGNORE_GCC("-Wstringop-overflow")
 
-std::optional<error_type> error_type_from_code_slow(
+std::optional<diag_type> error_type_from_code_slow(
     std::string_view code) noexcept {
-  for (int i = 0; i < error_type_count; ++i) {
+  for (int i = 0; i < diag_type_count; ++i) {
     // 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);
+      return static_cast<diag_type>(i);
     }
   }
   return std::nullopt;
diff --git a/src/emacs-lisp-error-reporter.cpp b/src/emacs-lisp-error-reporter.cpp
@@ -22,7 +22,7 @@ void emacs_lisp_error_reporter::set_source(padded_string_view input) {
   this->locator_.emplace(input);
 }
 
-void emacs_lisp_error_reporter::report_impl(error_type type, void *error) {
+void emacs_lisp_error_reporter::report_impl(diag_type type, void *error) {
   QLJS_ASSERT(this->locator_.has_value());
   emacs_lisp_error_formatter formatter(/*output=*/&this->output_,
                                        /*locator=*/*this->locator_);
diff --git a/src/error-debug.cpp b/src/error-debug.cpp
@@ -6,10 +6,10 @@
 #include <quick-lint-js/unreachable.h>
 
 namespace quick_lint_js {
-std::ostream& operator<<(std::ostream& out, error_type type) {
+std::ostream& operator<<(std::ostream& out, diag_type type) {
   switch (type) {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
-  case error_type::name:                                               \
+  case diag_type::name:                                                \
     return out << #name;
     QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
diff --git a/src/error-list.cpp b/src/error-list.cpp
@@ -99,7 +99,7 @@ parsed_error_list parse_error_list(const char* const raw_error_list) {
 
 void compiled_error_list::add(const parsed_error_list& error_list) {
   auto add_code = [this](std::string_view code, auto& code_set) -> void {
-    std::optional<error_type> code_error_type = error_type_from_code_slow(code);
+    std::optional<diag_type> code_error_type = error_type_from_code_slow(code);
     if (code_error_type.has_value()) {
       code_set[static_cast<std::size_t>(*code_error_type)] = true;
     } else {
@@ -159,7 +159,7 @@ std::vector<std::string> compiled_error_list::parse_warnings() const {
   return warnings;
 }
 
-bool compiled_error_list::is_present(error_type type) const noexcept {
+bool compiled_error_list::is_present(diag_type type) const noexcept {
   bool is_default = true;  // For now, all codes are enabled by default.
   bool present = true;
   for (const codes& c : this->parsed_error_lists_) {
diff --git a/src/lsp-error-reporter.cpp b/src/lsp-error-reporter.cpp
@@ -28,7 +28,7 @@ lsp_error_reporter::lsp_error_reporter(byte_buffer &output,
 
 void lsp_error_reporter::finish() { this->output_.append_copy(u8"]"sv); }
 
-void lsp_error_reporter::report_impl(error_type type, void *error) {
+void lsp_error_reporter::report_impl(diag_type type, void *error) {
   if (this->need_comma_) {
     this->output_.append_copy(u8",\n"sv);
   }
diff --git a/src/quick-lint-js/buffering-error-reporter.h b/src/quick-lint-js/buffering-error-reporter.h
@@ -20,7 +20,7 @@ class buffering_error_reporter final : public error_reporter {
 
   ~buffering_error_reporter() override;
 
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
   void copy_into(error_reporter *other) const;
   void move_into(error_reporter *other);
diff --git a/src/quick-lint-js/c-api-error-reporter.h b/src/quick-lint-js/c-api-error-reporter.h
@@ -35,7 +35,7 @@ class c_api_error_reporter final : public error_reporter {
 
   const Diagnostic *get_diagnostics();
 
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
  private:
   char8 *allocate_c_string(string8_view);
diff --git a/src/quick-lint-js/diagnostic.h b/src/quick-lint-js/diagnostic.h
@@ -22,7 +22,7 @@
 #endif
 
 namespace quick_lint_js {
-enum class error_type;
+enum class diag_type;
 
 enum class diagnostic_severity : std::uint8_t {
   error,
@@ -89,8 +89,8 @@ struct diagnostic_info {
   diagnostic_message_args message_args[diagnostic_max_message_count];
 };
 
-const diagnostic_info &get_diagnostic_info(error_type) noexcept;
-std::optional<error_type> error_type_from_code_slow(
+const diagnostic_info &get_diagnostic_info(diag_type) noexcept;
+std::optional<diag_type> error_type_from_code_slow(
     std::string_view code) noexcept;
 }
 
diff --git a/src/quick-lint-js/emacs-lisp-error-reporter.h b/src/quick-lint-js/emacs-lisp-error-reporter.h
@@ -26,7 +26,7 @@ class emacs_lisp_error_reporter final : public error_reporter {
   void set_source(padded_string_view input);
   void finish();
 
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
  private:
   output_stream &output_;
diff --git a/src/quick-lint-js/error-list.h b/src/quick-lint-js/error-list.h
@@ -32,14 +32,14 @@ class compiled_error_list {
   std::vector<std::string> parse_errors(std::string_view cli_option_name) const;
   std::vector<std::string> parse_warnings() const;
 
-  bool is_present(error_type) const noexcept;
+  bool is_present(diag_type) const noexcept;
 
   bool is_user_provided() const noexcept;
 
  private:
   struct codes {
-    std::bitset<error_type_count> included_codes;
-    std::bitset<error_type_count> excluded_codes;
+    std::bitset<diag_type_count> included_codes;
+    std::bitset<diag_type_count> excluded_codes;
     std::vector<std::string_view> included_categories;
     std::vector<std::string_view> excluded_categories;
     bool override_defaults;
diff --git a/src/quick-lint-js/error-reporter.h b/src/quick-lint-js/error-reporter.h
@@ -26,14 +26,14 @@ class error_reporter {
   QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
-  virtual void report_impl(error_type type, void *error) = 0;
+  virtual void report_impl(diag_type type, void *error) = 0;
 };
 
 class null_error_reporter : public error_reporter {
  public:
   static null_error_reporter instance;
 
-  void report_impl(error_type, void *) override {}
+  void report_impl(diag_type, void *) override {}
 };
 inline null_error_reporter null_error_reporter::instance;
 }
diff --git a/src/quick-lint-js/error-tape.h b/src/quick-lint-js/error-tape.h
@@ -24,7 +24,7 @@ class error_tape final : public error_reporter {
     return this->found_matching_error_;
   }
 
-  void report_impl(error_type type, void *error) override final {
+  void report_impl(diag_type type, void *error) override final {
     if (this->predicate_->is_present(type)) {
       this->found_matching_error_ = true;
     }
diff --git a/src/quick-lint-js/error.h b/src/quick-lint-js/error.h
@@ -1624,30 +1624,30 @@ namespace quick_lint_js {
 QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
-enum class error_type {
+enum class diag_type {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) name,
   QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 };
 
-std::ostream& operator<<(std::ostream&, error_type);
+std::ostream& operator<<(std::ostream&, diag_type);
 
 template <class Error>
-struct error_type_from_type_detail;
+struct diag_type_from_type_detail;
 
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
   template <>                                                          \
-  struct error_type_from_type_detail<name> {                           \
-    static constexpr error_type type = error_type::name;               \
+  struct diag_type_from_type_detail<name> {                            \
+    static constexpr diag_type type = diag_type::name;                 \
   };
 QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
 template <class Error>
-inline constexpr error_type error_type_from_type =
-    error_type_from_type_detail<Error>::type;
+inline constexpr diag_type error_type_from_type =
+    diag_type_from_type_detail<Error>::type;
 
-inline constexpr int error_type_count = 0
+inline constexpr int diag_type_count = 0
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) +1
     QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
diff --git a/src/quick-lint-js/lsp-error-reporter.h b/src/quick-lint-js/lsp-error-reporter.h
@@ -29,7 +29,7 @@ class lsp_error_reporter final : public error_reporter {
 
   void finish();
 
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
  private:
   byte_buffer &output_;
diff --git a/src/quick-lint-js/text-error-reporter.h b/src/quick-lint-js/text-error-reporter.h
@@ -26,7 +26,7 @@ class text_error_reporter final : public error_reporter {
 
   void set_source(padded_string_view input, const char *file_name);
 
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
  private:
   output_stream &output_;
diff --git a/src/quick-lint-js/vim-qflist-json-error-reporter.h b/src/quick-lint-js/vim-qflist-json-error-reporter.h
@@ -31,7 +31,7 @@ class vim_qflist_json_error_reporter final : public error_reporter {
 
   void finish();
 
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
  private:
   output_stream &output_;
diff --git a/src/text-error-reporter.cpp b/src/text-error-reporter.cpp
@@ -28,7 +28,7 @@ void text_error_reporter::set_source(padded_string_view input,
   this->file_path_ = file_path;
 }
 
-void text_error_reporter::report_impl(error_type type, void *error) {
+void text_error_reporter::report_impl(diag_type type, void *error) {
   QLJS_ASSERT(this->file_path_);
   QLJS_ASSERT(this->locator_.has_value());
   text_error_formatter formatter(
diff --git a/src/vim-qflist-json-error-reporter.cpp b/src/vim-qflist-json-error-reporter.cpp
@@ -52,7 +52,7 @@ void vim_qflist_json_error_reporter::finish() {
   this->output_.append_literal(u8"]}"sv);
 }
 
-void vim_qflist_json_error_reporter::report_impl(error_type type, void *error) {
+void vim_qflist_json_error_reporter::report_impl(diag_type type, void *error) {
   if (this->need_comma_) {
     this->output_.append_literal(u8",\n"sv);
   }
diff --git a/test/error-collector.cpp b/test/error-collector.cpp
@@ -7,10 +7,10 @@
 #include <quick-lint-js/unreachable.h>
 
 namespace quick_lint_js {
-void error_collector::report_impl(error_type type, void *error) {
+void error_collector::report_impl(diag_type type, void *error) {
   switch (type) {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
-  case error_type::name:                                               \
+  case diag_type::name:                                                \
     this->errors.emplace_back(*reinterpret_cast<const name *>(error)); \
     break;
     QLJS_X_DIAG_TYPES
@@ -20,16 +20,16 @@ void error_collector::report_impl(error_type type, void *error) {
 
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
   error_collector::error::error(const name &data)                      \
-      : type_(error_type::name), variant_##name##_(std::move(data)) {}
+      : type_(diag_type::name), variant_##name##_(std::move(data)) {}
 QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
-error_type error_collector::error::type() const noexcept { return this->type_; }
+diag_type error_collector::error::type() const noexcept { return this->type_; }
 
 const char *error_collector::error::error_code() const noexcept {
   switch (this->type_) {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
-  case error_type::name:                                               \
+  case diag_type::name:                                                \
     return code;
     QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
@@ -44,7 +44,7 @@ const void *error_collector::error::data() const noexcept {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call)     \
   template <>                                                              \
   bool holds_alternative<name>(const error_collector::error &e) noexcept { \
-    return e.type_ == error_type::name;                                    \
+    return e.type_ == diag_type::name;                                     \
   }                                                                        \
                                                                            \
   template <>                                                              \
diff --git a/test/error-matcher.cpp b/test/error-matcher.cpp
@@ -178,18 +178,17 @@ source_code_span error_matcher::field::get_span(const void *error_object) const
   QLJS_UNREACHABLE();
 }
 
-error_matcher::error_matcher(error_type type)
-    : state_{type, std::nullopt, {}} {}
+error_matcher::error_matcher(diag_type type) : state_{type, std::nullopt, {}} {}
 
-error_matcher::error_matcher(padded_string_view input, error_type type,
+error_matcher::error_matcher(padded_string_view input, diag_type type,
                              field field_0)
     : state_{type, input, {field_0}} {}
 
-error_matcher::error_matcher(padded_string_view input, error_type type,
+error_matcher::error_matcher(padded_string_view input, diag_type type,
                              field field_0, field field_1)
     : state_{type, input, {field_0, field_1}} {}
 
-error_matcher::error_matcher(padded_string_view input, error_type type,
+error_matcher::error_matcher(padded_string_view input, diag_type type,
                              field field_0, field field_1, field field_2)
     : state_{type, input, {field_0, field_1, field_2}} {}
 
diff --git a/test/quick-lint-js/error-collector.h b/test/quick-lint-js/error-collector.h
@@ -15,7 +15,7 @@
 
 namespace quick_lint_js {
 struct error_collector : public error_reporter {
-  void report_impl(error_type type, void *error) override;
+  void report_impl(diag_type type, void *error) override;
 
   // Like std::variant<(error types)>, but with much faster compilation.
   class error {
@@ -25,7 +25,7 @@ struct error_collector : public error_reporter {
     QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
-    error_type type() const noexcept;
+    diag_type type() const noexcept;
     const char *error_code() const noexcept;
     const void *data() const noexcept;
 
@@ -38,7 +38,7 @@ struct error_collector : public error_reporter {
     friend void PrintTo(const error &, std::ostream *);
 
    private:
-    error_type type_;
+    diag_type type_;
     union {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
   name variant_##name##_;
diff --git a/test/quick-lint-js/error-matcher.h b/test/quick-lint-js/error-matcher.h
diff --git a/test/test-error-list.cpp b/test/test-error-list.cpp
diff --git a/test/test-options.cpp b/test/test-options.cpp
diff --git a/test/test-translation.cpp b/test/test-translation.cpp

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ void c_api_error_reporter<Diagnostic, Locator>::reset() {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`template <class Diagnostic, class Locator>`
`37`		`-void c_api_error_reporter<Diagnostic, Locator>::report_impl(error_type type,`
	`37`	`+void c_api_error_reporter<Diagnostic, Locator>::report_impl(diag_type type,`
`38`	`38`	`void *error) {`
`39`	`39`	`c_api_error_formatter formatter(this);`
`40`	`40`	`formatter.format(get_diagnostic_info(type), error);`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ void emacs_lisp_error_reporter::set_source(padded_string_view input) {`
`22`	`22`	`this->locator_.emplace(input);`
`23`	`23`	`}`
`24`	`24`
`25`		`-void emacs_lisp_error_reporter::report_impl(error_type type, void *error) {`
	`25`	`+void emacs_lisp_error_reporter::report_impl(diag_type type, void *error) {`
`26`	`26`	`QLJS_ASSERT(this->locator_.has_value());`
`27`	`27`	`emacs_lisp_error_formatter formatter(/output=/&this->output_,`
`28`	`28`	`/locator=/*this->locator_);`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ lsp_error_reporter::lsp_error_reporter(byte_buffer &output,`
`28`	`28`
`29`	`29`	`void lsp_error_reporter::finish() { this->output_.append_copy(u8"]"sv); }`
`30`	`30`
`31`		`-void lsp_error_reporter::report_impl(error_type type, void *error) {`
	`31`	`+void lsp_error_reporter::report_impl(diag_type type, void *error) {`
`32`	`32`	`if (this->need_comma_) {`
`33`	`33`	`this->output_.append_copy(u8",\n"sv);`
`34`	`34`	`}`