refactor: rename *_error_reporter -> *_diag_reporter

Author: strager

benchmark/benchmark-configuration.cpp

@@ -13,12 +13,12 @@ namespace {
 void benchmark_parse_config_json(::benchmark::State& state,
                                  string8_view config_json) {
   padded_string config_json_string(config_json);
-  null_error_reporter error_reporter;
+  null_diag_reporter diag_reporter;
 
   configuration config;
   for (auto _ : state) {
     config.reset();
-    config.load_from_json(&config_json_string, &error_reporter);
+    config.load_from_json(&config_json_string, &diag_reporter);
     ::benchmark::ClobberMemory();
   }
 }

benchmark/benchmark-lex.cpp

@@ -12,7 +12,7 @@ namespace {
 void benchmark_lex(::benchmark::State &state, string8_view raw_source) {
   padded_string source(raw_source);
   for (auto _ : state) {
-    lexer l(&source, &null_error_reporter::instance);
+    lexer l(&source, &null_diag_reporter::instance);
     while (l.peek().type != token_type::end_of_file) {
       l.skip();
     }

benchmark/benchmark-lint.cpp

@@ -33,12 +33,12 @@ void benchmark_lint(benchmark::State &state) {
   padded_string source = quick_lint_js::read_file_or_exit(source_path);
 
   configuration config;
-  parser p(&source, &null_error_reporter::instance);
+  parser p(&source, &null_diag_reporter::instance);
   buffering_visitor visitor(new_delete_resource());
   p.parse_and_visit_module(visitor);
 
   for (auto _ : state) {
-    linter l(&null_error_reporter::instance, &config.globals());
+    linter l(&null_diag_reporter::instance, &config.globals());
     visitor.copy_into(l);
   }
 }
@@ -58,8 +58,8 @@ void benchmark_parse_and_lint(benchmark::State &state) {
 
   configuration config;
   for (auto _ : state) {
-    parser p(&source, &null_error_reporter::instance);
-    linter l(&null_error_reporter::instance, &config.globals());
+    parser p(&source, &null_diag_reporter::instance);
+    linter l(&null_diag_reporter::instance, &config.globals());
     p.parse_and_visit_module(l);
   }
 }
@@ -97,7 +97,7 @@ void benchmark_undeclared_variable_references(benchmark::State &state) {
   }
 
   for (auto _ : state) {
-    linter l(&null_error_reporter::instance, &globals);
+    linter l(&null_diag_reporter::instance, &globals);
     for (identifier &variable_use : variable_use_identifiers) {
       l.visit_variable_use(variable_use);
     }

benchmark/benchmark-parse.cpp

@@ -29,7 +29,7 @@ void benchmark_parse_file(benchmark::State &state) {
   padded_string source = quick_lint_js::read_file_or_exit(source_path);
 
   for (auto _ : state) {
-    parser p(&source, &null_error_reporter::instance);
+    parser p(&source, &null_diag_reporter::instance);
     null_visitor visitor;
     p.parse_and_visit_module(visitor);
   }
@@ -39,7 +39,7 @@ BENCHMARK(benchmark_parse_file);
 void benchmark_parse(benchmark::State &state, string8_view raw_source) {
   padded_string source(raw_source);
   for (auto _ : state) {
-    parser p(&source, &null_error_reporter::instance);
+    parser p(&source, &null_diag_reporter::instance);
     null_visitor visitor;
     p.parse_and_visit_module(visitor);
   }

plugin/vscode/quick-lint-js-vscode-node.cpp

@@ -98,18 +98,18 @@ class qljs_document : public ::Napi::ObjectWrap<qljs_document> {
     QLJS_ASSERT(this->type_ == document_type::lintable);
     vscode->load_non_persistent(env);
 
-    vscode_error_reporter error_reporter(
-        vscode, env, &this->document_.locator(), this->uri());
+    vscode_diag_reporter diag_reporter(vscode, env, &this->document_.locator(),
+                                       this->uri());
     parser_options p_options;
     p_options.jsx = true;
-    parser p(this->document_.string(), &error_reporter, p_options);
-    linter l(&error_reporter, &this->config_->globals());
+    parser p(this->document_.string(), &diag_reporter, p_options);
+    linter l(&diag_reporter, &this->config_->globals());
     bool ok = p.parse_and_visit_module_catching_fatal_parse_errors(l);
     if (!ok) {
       // TODO(strager): Show a pop-up message explaining that the parser
       // crashed.
     }
-    return std::move(error_reporter).diagnostics();
+    return std::move(diag_reporter).diagnostics();
   }
 
   ::Napi::Array lint_config(::Napi::Env env, vscode_module* vscode,
@@ -118,9 +118,9 @@ class qljs_document : public ::Napi::ObjectWrap<qljs_document> {
     vscode->load_non_persistent(env);
 
     lsp_locator locator(&loaded_config->file_content);
-    vscode_error_reporter error_reporter(vscode, env, &locator, this->uri());
-    loaded_config->errors.copy_into(&error_reporter);
-    return std::move(error_reporter).diagnostics();
+    vscode_diag_reporter diag_reporter(vscode, env, &locator, this->uri());
+    loaded_config->errors.copy_into(&diag_reporter);
+    return std::move(diag_reporter).diagnostics();
   }
 
   ::Napi::Value uri() { return this->vscode_document_.Value().uri(); }

plugin/vscode/quick-lint-js/vscode-error-reporter.h

@@ -124,11 +124,11 @@ class vscode_error_formatter
   string8 message_;
 };
 
-class vscode_error_reporter final : public error_reporter {
+class vscode_diag_reporter final : public diag_reporter {
  public:
-  explicit vscode_error_reporter(vscode_module* vscode, ::Napi::Env env,
-                                 const lsp_locator* locator,
-                                 ::Napi::Value document_uri) noexcept
+  explicit vscode_diag_reporter(vscode_module* vscode, ::Napi::Env env,
+                                const lsp_locator* locator,
+                                ::Napi::Value document_uri) noexcept
       : vscode_(vscode),
         env_(env),
         diagnostics_(::Napi::Array::New(env)),

src/buffering-error-reporter.cpp

@@ -13,7 +13,7 @@
 #include <type_traits>
 
 namespace quick_lint_js {
-struct buffering_error_reporter::impl {
+struct buffering_diag_reporter::impl {
   explicit impl(boost::container::pmr::memory_resource *memory) noexcept
       : memory_(memory) {}
 
@@ -38,25 +38,25 @@ struct buffering_error_reporter::impl {
       errors_{this->memory_};
 };
 
-void buffering_error_reporter::impl_deleter::operator()(impl *i) noexcept {
+void buffering_diag_reporter::impl_deleter::operator()(impl *i) noexcept {
   if (i) {
     delete_object(i->memory_, i);
   }
 }
 
-buffering_error_reporter::buffering_error_reporter(
+buffering_diag_reporter::buffering_diag_reporter(
     boost::container::pmr::memory_resource *memory)
     : impl_(new_object<impl>(memory, memory)) {}
 
-buffering_error_reporter::buffering_error_reporter(
-    buffering_error_reporter &&) = default;
+buffering_diag_reporter::buffering_diag_reporter(buffering_diag_reporter &&) =
+    default;
 
-buffering_error_reporter &buffering_error_reporter::operator=(
-    buffering_error_reporter &&) = default;
+buffering_diag_reporter &buffering_diag_reporter::operator=(
+    buffering_diag_reporter &&) = default;
 
-buffering_error_reporter::~buffering_error_reporter() = default;
+buffering_diag_reporter::~buffering_diag_reporter() = default;
 
-void buffering_error_reporter::report_impl(diag_type type, void *error) {
+void buffering_diag_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),
@@ -69,21 +69,21 @@ void buffering_error_reporter::report_impl(diag_type type, void *error) {
   std::memcpy(&e.error, error, error_sizes[static_cast<std::ptrdiff_t>(type)]);
 }
 
-void buffering_error_reporter::copy_into(error_reporter *other) const {
+void buffering_diag_reporter::copy_into(diag_reporter *other) const {
   for (impl::any_error &error : this->impl_->errors_) {
     other->report_impl(error.type, &error.error);
   }
 }
 
-void buffering_error_reporter::move_into(error_reporter *other) {
+void buffering_diag_reporter::move_into(diag_reporter *other) {
   this->copy_into(other);
 }
 
-bool buffering_error_reporter::empty() const noexcept {
+bool buffering_diag_reporter::empty() const noexcept {
   return this->impl_->errors_.empty();
 }
 
-void buffering_error_reporter::clear() noexcept {
+void buffering_diag_reporter::clear() noexcept {
   return this->impl_->errors_.clear();
 }
 }

src/c-api-error-reporter.cpp

@@ -18,38 +18,38 @@
 
 namespace quick_lint_js {
 template <class Diagnostic, class Locator>
-c_api_error_reporter<Diagnostic, Locator>::c_api_error_reporter() = default;
+c_api_diag_reporter<Diagnostic, Locator>::c_api_diag_reporter() = default;
 
 template <class Diagnostic, class Locator>
-void c_api_error_reporter<Diagnostic, Locator>::set_input(
+void c_api_diag_reporter<Diagnostic, Locator>::set_input(
     padded_string_view input, const Locator *locator) {
   this->locator_ = locator;
   this->input_ = input.data();
 }
 
 template <class Diagnostic, class Locator>
-void c_api_error_reporter<Diagnostic, Locator>::reset() {
+void c_api_diag_reporter<Diagnostic, Locator>::reset() {
   this->diagnostics_.clear();
   // TODO(strager): Release allocated string memory.
 }
 
 template <class Diagnostic, class Locator>
-void c_api_error_reporter<Diagnostic, Locator>::report_impl(diag_type type,
-                                                            void *error) {
+void c_api_diag_reporter<Diagnostic, Locator>::report_impl(diag_type type,
+                                                           void *error) {
   c_api_error_formatter formatter(this);
   formatter.format(get_diagnostic_info(type), error);
 }
 
 template <class Diagnostic, class Locator>
-const Diagnostic *c_api_error_reporter<Diagnostic, Locator>::get_diagnostics() {
+const Diagnostic *c_api_diag_reporter<Diagnostic, Locator>::get_diagnostics() {
   // Null-terminate the returned errors.
   this->diagnostics_.emplace_back();
 
   return this->diagnostics_.data();
 }
 
 template <class Diagnostic, class Locator>
-char8 *c_api_error_reporter<Diagnostic, Locator>::allocate_c_string(
+char8 *c_api_diag_reporter<Diagnostic, Locator>::allocate_c_string(
     string8_view string) {
   char8 *result =
       this->string_allocator_.template allocate_uninitialized_array<char8>(
@@ -61,7 +61,7 @@ char8 *c_api_error_reporter<Diagnostic, Locator>::allocate_c_string(
 
 template <class Diagnostic, class Locator>
 c_api_error_formatter<Diagnostic, Locator>::c_api_error_formatter(
-    c_api_error_reporter<Diagnostic, Locator> *reporter)
+    c_api_diag_reporter<Diagnostic, Locator> *reporter)
     : reporter_(reporter) {}
 
 template <class Diagnostic, class Locator>
@@ -123,7 +123,7 @@ void c_api_error_formatter<Diagnostic, Locator>::write_after_message(
 
 template class c_api_error_formatter<qljs_web_demo_diagnostic,
                                      web_demo_locator>;
-template class c_api_error_reporter<qljs_web_demo_diagnostic, web_demo_locator>;
+template class c_api_diag_reporter<qljs_web_demo_diagnostic, web_demo_locator>;
 }
 
 // quick-lint-js finds bugs in JavaScript programs.

src/c-api.cpp

@@ -55,8 +55,8 @@ class qljs_document_base {
 struct qljs_web_demo_document final
     : public quick_lint_js::qljs_document_base<
           quick_lint_js::web_demo_locator,
-          quick_lint_js::c_api_error_reporter<
-              qljs_web_demo_diagnostic, quick_lint_js::web_demo_locator>> {
+          quick_lint_js::c_api_diag_reporter<qljs_web_demo_diagnostic,
+                                             quick_lint_js::web_demo_locator>> {
  public:
   void set_text(quick_lint_js::string8_view replacement) {
     this->document_.set_text(replacement);
@@ -66,7 +66,7 @@ struct qljs_web_demo_document final
     quick_lint_js::padded_string padded_text(text);
     this->config_.reset();
     this->config_.load_from_json(&padded_text,
-                                 &quick_lint_js::null_error_reporter::instance);
+                                 &quick_lint_js::null_diag_reporter::instance);
   }
 };
 

src/configuration.cpp

@@ -66,7 +66,7 @@ void configuration::remove_global_variable(string8_view name) {
 }
 
 void configuration::load_from_json(padded_string_view json,
-                                   error_reporter* reporter) {
+                                   diag_reporter* reporter) {
   ::simdjson::ondemand::parser json_parser;
   ::simdjson::ondemand::document document;
   ::simdjson::error_code parse_error =
@@ -145,8 +145,7 @@ void configuration::reset() {
 }
 
 bool configuration::load_global_groups_from_json(
-    ::simdjson::ondemand::value& global_groups_value,
-    error_reporter* reporter) {
+    ::simdjson::ondemand::value& global_groups_value, diag_reporter* reporter) {
   ::simdjson::ondemand::json_type global_groups_value_type;
   if (global_groups_value.type().get(global_groups_value_type) !=
       ::simdjson::SUCCESS) {
@@ -220,7 +219,7 @@ bool configuration::load_global_groups_from_json(
 }
 
 bool configuration::load_globals_from_json(
-    ::simdjson::ondemand::object& globals_value, error_reporter* reporter) {
+    ::simdjson::ondemand::object& globals_value, diag_reporter* reporter) {
   for (simdjson::simdjson_result<::simdjson::ondemand::field> global_field :
        globals_value) {
     std::string_view key;
@@ -393,7 +392,7 @@ bool configuration::should_remove_global_variable(string8_view name) {
 template <class Error>
 bool configuration::get_bool_or_default(
     ::simdjson::simdjson_result<::simdjson::ondemand::value>&& value, bool* out,
-    bool default_value, error_reporter* reporter) {
+    bool default_value, diag_reporter* reporter) {
   ::simdjson::ondemand::value v;
   ::simdjson::error_code error = value.get(v);
   switch (error) {
@@ -415,7 +414,7 @@ bool configuration::get_bool_or_default(
 }
 
 void configuration::report_json_error(padded_string_view json,
-                                      error_reporter* reporter) {
+                                      diag_reporter* reporter) {
   // TODO(strager): Produce better error messages. simdjson provides no location
   // information for errors:
   // https://github.com/simdjson/simdjson/issues/237