refactor: rename error_list -> diag_code_list

* Change terminology from 'error' to 'diag'.
* Add the word 'code' to clarify that the module deals with codes only.
  This disambiguates from buffering_diag_reporter, for example, which
  stores a list of reported diags.

Author: strager

src/CMakeLists.txt

@@ -56,12 +56,12 @@ quick_lint_js_add_library(
   cli-location.cpp
   configuration-loader.cpp
   configuration.cpp
+  diag-code-list.cpp
   diagnostic-formatter.cpp
   diagnostic.cpp
   document.cpp
   emacs-lisp-diag-reporter.cpp
   emacs-location.cpp
-  error-list.cpp
   file-canonical.cpp
   file-handle.cpp
   file-path.cpp
@@ -107,14 +107,14 @@ quick_lint_js_add_library(
   quick-lint-js/consteval.h
   quick-lint-js/cpp.h
   quick-lint-js/crash.h
+  quick-lint-js/diag-code-list.h
   quick-lint-js/diag-reporter.h
   quick-lint-js/diagnostic-formatter.h
   quick-lint-js/diagnostic-types.h
   quick-lint-js/diagnostic.h
   quick-lint-js/document.h
   quick-lint-js/emacs-lisp-diag-reporter.h
   quick-lint-js/emacs-location.h
-  quick-lint-js/error-list.h
   quick-lint-js/event-loop.h
   quick-lint-js/expression.h
   quick-lint-js/feature.h

src/error-list.cpp renamed to src/diag-code-list.cpp

@@ -4,9 +4,9 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
+#include <quick-lint-js/diag-code-list.h>
 #include <quick-lint-js/diagnostic-types.h>
 #include <quick-lint-js/diagnostic.h>
-#include <quick-lint-js/error-list.h>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -21,12 +21,13 @@ bool contains(const Container& container, const T& item) {
 }
 }
 
-bool parsed_error_list::error_missing_predicate() const noexcept {
+bool parsed_diag_code_list::error_missing_predicate() const noexcept {
   return this->included_codes.empty() && this->excluded_codes.empty() &&
          this->included_categories.empty() && this->excluded_categories.empty();
 }
 
-parsed_error_list parse_error_list(const char* const raw_error_list) {
+parsed_diag_code_list parse_diag_code_list(
+    const char* const raw_diag_code_list) {
   static auto is_initial_category_character = [](char c) -> bool {
     return 'a' <= c && c <= 'z';
   };
@@ -37,51 +38,51 @@ parsed_error_list parse_error_list(const char* const raw_error_list) {
     return '0' <= c && c <= '9';
   };
 
-  parsed_error_list errors;
+  parsed_diag_code_list errors;
   std::size_t i = 0;
   bool need_comma = false;
 
   auto try_parse_category_or_code = [&](bool is_include) -> bool {
     auto parse_word = [&](auto& is_continue_character) -> std::string_view {
       std::size_t begin = i;
       i += 1;  // Skip initial character. Assume it is valid.
-      while (is_continue_character(raw_error_list[i])) {
+      while (is_continue_character(raw_diag_code_list[i])) {
         i += 1;
       }
       std::size_t end = i;
-      return std::string_view(&raw_error_list[begin], end - begin);
+      return std::string_view(&raw_diag_code_list[begin], end - begin);
     };
 
-    if (raw_error_list[i] == 'E') {
+    if (raw_diag_code_list[i] == 'E') {
       (is_include ? errors.included_codes : errors.excluded_codes)
           .emplace_back(parse_word(is_continue_code_character));
       return true;
-    } else if (is_initial_category_character(raw_error_list[i])) {
+    } else if (is_initial_category_character(raw_diag_code_list[i])) {
       (is_include ? errors.included_categories : errors.excluded_categories)
           .emplace_back(parse_word(is_continue_category_character));
       return true;
     } else {
-      errors.unexpected.emplace_back(&raw_error_list[i], 1);
+      errors.unexpected.emplace_back(&raw_diag_code_list[i], 1);
       return false;
     }
   };
 
   for (;;) {
-    i = i + std::strspn(&raw_error_list[i], " \t");
-    if (raw_error_list[i] == '\0') {
+    i = i + std::strspn(&raw_diag_code_list[i], " \t");
+    if (raw_diag_code_list[i] == '\0') {
       break;
     }
-    if (need_comma && raw_error_list[i] != ',') {
-      errors.unexpected.emplace_back(&raw_error_list[i], 1);
+    if (need_comma && raw_diag_code_list[i] != ',') {
+      errors.unexpected.emplace_back(&raw_diag_code_list[i], 1);
       break;
     }
-    i = i + std::strspn(&raw_error_list[i], " \t,");
+    i = i + std::strspn(&raw_diag_code_list[i], " \t,");
     need_comma = true;
 
-    if (raw_error_list[i] == '\0') {
+    if (raw_diag_code_list[i] == '\0') {
       break;
-    } else if (raw_error_list[i] == '+' || raw_error_list[i] == '-') {
-      bool is_include = raw_error_list[i] == '+';
+    } else if (raw_diag_code_list[i] == '+' || raw_diag_code_list[i] == '-') {
+      bool is_include = raw_diag_code_list[i] == '+';
       i += 1;
       if (!try_parse_category_or_code(/*is_include=*/is_include)) {
         break;
@@ -97,7 +98,7 @@ parsed_error_list parse_error_list(const char* const raw_error_list) {
   return errors;
 }
 
-void compiled_error_list::add(const parsed_error_list& error_list) {
+void compiled_diag_code_list::add(const parsed_diag_code_list& diag_code_list) {
   auto add_code = [this](std::string_view code, auto& code_set) -> void {
     std::optional<diag_type> code_error_type = error_type_from_code_slow(code);
     if (code_error_type.has_value()) {
@@ -107,23 +108,23 @@ void compiled_error_list::add(const parsed_error_list& error_list) {
     }
   };
 
-  codes& c = this->parsed_error_lists_.emplace_back();
-  for (std::string_view code : error_list.included_codes) {
+  codes& c = this->parsed_diag_code_lists_.emplace_back();
+  for (std::string_view code : diag_code_list.included_codes) {
     add_code(code, c.included_codes);
   }
-  for (std::string_view code : error_list.excluded_codes) {
+  for (std::string_view code : diag_code_list.excluded_codes) {
     add_code(code, c.excluded_codes);
   }
-  c.included_categories = error_list.included_categories;
-  c.excluded_categories = error_list.excluded_categories;
-  c.override_defaults = error_list.override_defaults;
+  c.included_categories = diag_code_list.included_categories;
+  c.excluded_categories = diag_code_list.excluded_categories;
+  c.override_defaults = diag_code_list.override_defaults;
 
-  if (error_list.error_missing_predicate()) {
+  if (diag_code_list.error_missing_predicate()) {
     this->has_missing_predicate_error_ = true;
   }
 }
 
-std::vector<std::string> compiled_error_list::parse_errors(
+std::vector<std::string> compiled_diag_code_list::parse_errors(
     std::string_view cli_option_name) const {
   std::vector<std::string> errors;
   if (this->has_missing_predicate_error_) {
@@ -133,7 +134,7 @@ std::vector<std::string> compiled_error_list::parse_errors(
   return errors;
 }
 
-std::vector<std::string> compiled_error_list::parse_warnings() const {
+std::vector<std::string> compiled_diag_code_list::parse_warnings() const {
   std::vector<std::string> warnings;
   auto check_category = [&warnings](std::string_view category) {
     if (category != "all") {
@@ -142,7 +143,7 @@ std::vector<std::string> compiled_error_list::parse_warnings() const {
     }
   };
 
-  for (const codes& c : this->parsed_error_lists_) {
+  for (const codes& c : this->parsed_diag_code_lists_) {
     for (std::string_view category : c.included_categories) {
       check_category(category);
     }
@@ -159,10 +160,10 @@ std::vector<std::string> compiled_error_list::parse_warnings() const {
   return warnings;
 }
 
-bool compiled_error_list::is_present(diag_type type) const noexcept {
+bool compiled_diag_code_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_) {
+  for (const codes& c : this->parsed_diag_code_lists_) {
     std::size_t error_type_index = static_cast<std::size_t>(type);
     if (c.override_defaults || c.excluded_codes[error_type_index] ||
         (is_default && contains(c.excluded_categories, "all"))) {
@@ -176,8 +177,8 @@ bool compiled_error_list::is_present(diag_type type) const noexcept {
   return present;
 }
 
-bool compiled_error_list::is_user_provided() const noexcept {
-  return !parsed_error_lists_.empty();
+bool compiled_diag_code_list::is_user_provided() const noexcept {
+  return !parsed_diag_code_lists_.empty();
 }
 }
 

src/main.cpp

@@ -11,9 +11,9 @@
 #include <quick-lint-js/char8.h>
 #include <quick-lint-js/configuration-loader.h>
 #include <quick-lint-js/configuration.h>
+#include <quick-lint-js/diag-code-list.h>
 #include <quick-lint-js/emacs-lisp-diag-reporter.h>
 #include <quick-lint-js/emacs-location.h>
-#include <quick-lint-js/error-list.h>
 #include <quick-lint-js/event-loop.h>
 #include <quick-lint-js/file.h>
 #include <quick-lint-js/language.h>
@@ -74,7 +74,7 @@ bool get_escape_errors(option_when escape_errors) {
 class any_diag_reporter {
  public:
   static any_diag_reporter make(output_format format, option_when escape_errors,
-                                compiled_error_list *exit_fail_on) {
+                                compiled_diag_code_list *exit_fail_on) {
     switch (format) {
     case output_format::default_format:
     case output_format::gnu_like:

src/options.cpp

@@ -100,7 +100,7 @@ options parse_options(int argc, char** argv) {
       next_vim_file_bufnr = bufnr;
     } else if (const char* arg_value =
                    parser.match_option_with_value("--exit-fail-on"sv)) {
-      o.exit_fail_on.add(parse_error_list(arg_value));
+      o.exit_fail_on.add(parse_diag_code_list(arg_value));
     } else if (parser.match_flag_option("--help"sv, "--h"sv) ||
                parser.match_flag_shorthand('h')) {
       o.help = true;

src/quick-lint-js/error-list.h renamed to src/quick-lint-js/diag-code-list.h

@@ -1,8 +1,8 @@
 // Copyright (C) 2020  Matthew "strager" Glazar
 // See end of file for extended copyright information.
 
-#ifndef QUICK_LINT_JS_ERROR_LIST_H
-#define QUICK_LINT_JS_ERROR_LIST_H
+#ifndef QUICK_LINT_JS_DIAG_CODE_LIST_H
+#define QUICK_LINT_JS_DIAG_CODE_LIST_H
 
 #include <array>
 #include <bitset>
@@ -12,7 +12,7 @@
 #include <vector>
 
 namespace quick_lint_js {
-struct parsed_error_list {
+struct parsed_diag_code_list {
   bool error_missing_predicate() const noexcept;
 
   std::vector<std::string_view> included_codes;
@@ -23,11 +23,11 @@ struct parsed_error_list {
   bool override_defaults = false;
 };
 
-parsed_error_list parse_error_list(const char* raw_error_list);
+parsed_diag_code_list parse_diag_code_list(const char* raw_diag_code_list);
 
-class compiled_error_list {
+class compiled_diag_code_list {
  public:
-  void add(const parsed_error_list&);
+  void add(const parsed_diag_code_list&);
 
   std::vector<std::string> parse_errors(std::string_view cli_option_name) const;
   std::vector<std::string> parse_warnings() const;
@@ -45,7 +45,7 @@ class compiled_error_list {
     bool override_defaults;
   };
 
-  std::vector<codes> parsed_error_lists_;
+  std::vector<codes> parsed_diag_code_lists_;
 
   // Collected errors and warnings:
   std::vector<std::string_view> unknown_codes_;

src/quick-lint-js/options.h

@@ -5,7 +5,7 @@
 #define QUICK_LINT_JS_OPTIONS_H
 
 #include <optional>
-#include <quick-lint-js/error-list.h>
+#include <quick-lint-js/diag-code-list.h>
 #include <vector>
 
 namespace quick_lint_js {
@@ -38,7 +38,7 @@ struct options {
   quick_lint_js::option_when diagnostic_hyperlinks =
       quick_lint_js::option_when::auto_;
   std::vector<file_to_lint> files_to_lint;
-  compiled_error_list exit_fail_on;
+  compiled_diag_code_list exit_fail_on;
 
   std::vector<const char *> error_unrecognized_options;
   bool has_multiple_stdin = false;

src/quick-lint-js/reported-diag-statistics.h

@@ -4,9 +4,9 @@
 #ifndef QUICK_LINT_JS_REPORTED_DIAG_STATISTICS_H
 #define QUICK_LINT_JS_REPORTED_DIAG_STATISTICS_H
 
+#include <quick-lint-js/diag-code-list.h>
 #include <quick-lint-js/diag-reporter.h>
 #include <quick-lint-js/diagnostic-types.h>
-#include <quick-lint-js/error-list.h>
 #include <quick-lint-js/text-diag-reporter.h>
 #include <quick-lint-js/token.h>
 #include <quick-lint-js/vim-qflist-json-diag-reporter.h>
@@ -16,7 +16,7 @@ template <typename T>
 class reported_diag_statistics final : public diag_reporter {
  public:
   explicit reported_diag_statistics(T reporter,
-                                    const compiled_error_list *predicate)
+                                    const compiled_diag_code_list *predicate)
       : reporter_(reporter), predicate_(predicate) {}
 
   T *get_reporter() { return &(this->reporter_); }
@@ -35,7 +35,7 @@ class reported_diag_statistics final : public diag_reporter {
  private:
   T reporter_;
 
-  const compiled_error_list *predicate_;
+  const compiled_diag_code_list *predicate_;
   bool found_matching_error_ = false;
 };
 }

test/CMakeLists.txt

@@ -38,12 +38,12 @@ quick_lint_js_add_executable(
   test-configuration-loader.cpp
   test-configuration.cpp
   test-crash.cpp
+  test-diag-code-list.cpp
   test-diagnostic-formatter.cpp
   test-diagnostic.cpp
   test-document.cpp
   test-emacs-lisp-diag-reporter.cpp
   test-emacs-location.cpp
-  test-error-list.cpp
   test-error-matcher.cpp
   test-error.cpp
   test-event-loop.cpp