refactor: fix vestigial references to 'error' -> 'diag'

Author: strager

src/CMakeLists.txt

@@ -251,8 +251,8 @@ quick_lint_js_add_library(
   quick-lint-js-lib-debug
   char8-debug.cpp
   cli-location-debug.cpp
+  diag-debug.cpp
   emacs-location-debug.cpp
-  error-debug.cpp
   language-debug.cpp
   lex-debug.cpp
   lsp-location-debug.cpp

src/c-api-diag-reporter.cpp

@@ -42,7 +42,7 @@ void c_api_diag_reporter<Diagnostic, Locator>::report_impl(diag_type type,
 
 template <class Diagnostic, class Locator>
 const Diagnostic *c_api_diag_reporter<Diagnostic, Locator>::get_diagnostics() {
-  // Null-terminate the returned errors.
+  // Null-terminate the returned diagnostics.
   this->diagnostics_.emplace_back();
 
   return this->diagnostics_.data();

src/diag-code-list.cpp

@@ -38,7 +38,7 @@ parsed_diag_code_list parse_diag_code_list(
     return '0' <= c && c <= '9';
   };
 
-  parsed_diag_code_list errors;
+  parsed_diag_code_list diag_codes;
   std::size_t i = 0;
   bool need_comma = false;
 
@@ -54,15 +54,16 @@ parsed_diag_code_list parse_diag_code_list(
     };
 
     if (raw_diag_code_list[i] == 'E') {
-      (is_include ? errors.included_codes : errors.excluded_codes)
+      (is_include ? diag_codes.included_codes : diag_codes.excluded_codes)
           .emplace_back(parse_word(is_continue_code_character));
       return true;
     } else if (is_initial_category_character(raw_diag_code_list[i])) {
-      (is_include ? errors.included_categories : errors.excluded_categories)
+      (is_include ? diag_codes.included_categories
+                  : diag_codes.excluded_categories)
           .emplace_back(parse_word(is_continue_category_character));
       return true;
     } else {
-      errors.unexpected.emplace_back(&raw_diag_code_list[i], 1);
+      diag_codes.unexpected.emplace_back(&raw_diag_code_list[i], 1);
       return false;
     }
   };
@@ -73,7 +74,7 @@ parsed_diag_code_list parse_diag_code_list(
       break;
     }
     if (need_comma && raw_diag_code_list[i] != ',') {
-      errors.unexpected.emplace_back(&raw_diag_code_list[i], 1);
+      diag_codes.unexpected.emplace_back(&raw_diag_code_list[i], 1);
       break;
     }
     i = i + std::strspn(&raw_diag_code_list[i], " \t,");
@@ -91,18 +92,18 @@ parsed_diag_code_list parse_diag_code_list(
       if (!try_parse_category_or_code(/*is_include=*/true)) {
         break;
       }
-      errors.override_defaults = true;
+      diag_codes.override_defaults = true;
     }
   }
 
-  return errors;
+  return diag_codes;
 }
 
 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 = diag_type_from_code_slow(code);
-    if (code_error_type.has_value()) {
-      code_set[static_cast<std::size_t>(*code_error_type)] = true;
+    std::optional<diag_type> code_diag_type = diag_type_from_code_slow(code);
+    if (code_diag_type.has_value()) {
+      code_set[static_cast<std::size_t>(*code_diag_type)] = true;
     } else {
       this->unknown_codes_.emplace_back(code);
     }
@@ -164,12 +165,12 @@ 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_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] ||
+    std::size_t diag_type_index = static_cast<std::size_t>(type);
+    if (c.override_defaults || c.excluded_codes[diag_type_index] ||
         (is_default && contains(c.excluded_categories, "all"))) {
       present = false;
     }
-    if (c.included_codes[error_type_index] ||
+    if (c.included_codes[diag_type_index] ||
         (is_default && contains(c.included_categories, "all"))) {
       present = true;
     }

src/error-debug.cpp renamed to src/diag-debug.cpp

@@ -132,8 +132,8 @@ void token::report_errors_for_escape_sequences_in_template(
     diag_reporter* reporter) const {
   QLJS_ASSERT(this->type == token_type::complete_template ||
               this->type == token_type::incomplete_template);
-  if (this->template_escape_sequence_errors) {
-    this->template_escape_sequence_errors->move_into(reporter);
+  if (this->template_escape_sequence_diagnostics) {
+    this->template_escape_sequence_diagnostics->move_into(reporter);
   }
 }
 
@@ -575,8 +575,8 @@ bool lexer::try_parse_current_token() {
     this->input_ += 1;
     parsed_template_body body = this->parse_template_body(
         this->input_, this->last_token_.begin, this->diag_reporter_);
-    this->last_token_.template_escape_sequence_errors =
-        body.escape_sequence_errors;
+    this->last_token_.template_escape_sequence_diagnostics =
+        body.escape_sequence_diagnostics;
     this->last_token_.type = body.type;
     this->input_ = body.end;
     this->last_token_.end = this->input_;
@@ -679,7 +679,7 @@ bool lexer::test_for_regexp(const char8* regexp_begin) {
   this->last_token_.begin = this->input_;
   this->reparse_as_regexp();
 
-  bool parsed_ok = !this->transaction_has_lex_errors(transaction);
+  bool parsed_ok = !this->transaction_has_lex_diagnostics(transaction);
   this->roll_back_transaction(std::move(transaction));
   return parsed_ok;
 }
@@ -868,16 +868,16 @@ void lexer::skip_in_template(const char8* template_begin) {
   parsed_template_body body = this->parse_template_body(
       this->input_, template_begin, this->diag_reporter_);
   this->last_token_.type = body.type;
-  this->last_token_.template_escape_sequence_errors =
-      body.escape_sequence_errors;
+  this->last_token_.template_escape_sequence_diagnostics =
+      body.escape_sequence_diagnostics;
   this->input_ = body.end;
   this->last_token_.end = body.end;
 }
 
 lexer::parsed_template_body lexer::parse_template_body(
     const char8* input, const char8* template_begin,
     diag_reporter* diag_reporter) {
-  buffering_diag_reporter* escape_sequence_errors = nullptr;
+  buffering_diag_reporter* escape_sequence_diagnostics = nullptr;
   const char8* c = input;
   for (;;) {
     switch (*c) {
@@ -886,7 +886,7 @@ lexer::parsed_template_body lexer::parse_template_body(
         diag_reporter->report(
             diag_unclosed_template{source_code_span(template_begin, c)});
         return parsed_template_body{token_type::complete_template, c,
-                                    escape_sequence_errors};
+                                    escape_sequence_diagnostics};
       } else {
         ++c;
         break;
@@ -895,7 +895,7 @@ lexer::parsed_template_body lexer::parse_template_body(
     case '`':
       ++c;
       return parsed_template_body{token_type::complete_template, c,
-                                  escape_sequence_errors};
+                                  escape_sequence_diagnostics};
 
     case '\\': {
       const char8* escape_sequence_start = c;
@@ -906,19 +906,19 @@ lexer::parsed_template_body lexer::parse_template_body(
           diag_reporter->report(
               diag_unclosed_template{source_code_span(template_begin, c)});
           return parsed_template_body{token_type::complete_template, c,
-                                      escape_sequence_errors};
+                                      escape_sequence_diagnostics};
         } else {
           ++c;
           break;
         }
       case 'u': {
-        if (!escape_sequence_errors) {
-          escape_sequence_errors =
+        if (!escape_sequence_diagnostics) {
+          escape_sequence_diagnostics =
               this->allocator_.new_object<buffering_diag_reporter>(
                   &this->allocator_);
         }
         c = this->parse_unicode_escape(escape_sequence_start,
-                                       escape_sequence_errors)
+                                       escape_sequence_diagnostics)
                 .end;
         break;
       }
@@ -933,7 +933,7 @@ lexer::parsed_template_body lexer::parse_template_body(
       if (c[1] == '{') {
         c += 2;
         return parsed_template_body{token_type::incomplete_template, c,
-                                    escape_sequence_errors};
+                                    escape_sequence_diagnostics};
       }
       ++c;
       break;
@@ -1110,9 +1110,9 @@ lexer_transaction lexer::begin_transaction() {
 }
 
 void lexer::commit_transaction(lexer_transaction&& transaction) {
-  buffering_diag_reporter* buffered_errors =
+  buffering_diag_reporter* buffered_diagnostics =
       static_cast<buffering_diag_reporter*>(this->diag_reporter_);
-  buffered_errors->move_into(transaction.old_diag_reporter);
+  buffered_diagnostics->move_into(transaction.old_diag_reporter);
 
   this->diag_reporter_ = transaction.old_diag_reporter;
 }
@@ -1124,11 +1124,11 @@ void lexer::roll_back_transaction(lexer_transaction&& transaction) {
   this->diag_reporter_ = transaction.old_diag_reporter;
 }
 
-bool lexer::transaction_has_lex_errors(const lexer_transaction&) const
+bool lexer::transaction_has_lex_diagnostics(const lexer_transaction&) const
     noexcept {
-  buffering_diag_reporter* buffered_errors =
+  buffering_diag_reporter* buffered_diagnostics =
       static_cast<buffering_diag_reporter*>(this->diag_reporter_);
-  return !buffered_errors->empty();
+  return !buffered_diagnostics->empty();
 }
 
 void lexer::insert_semicolon() {

src/lex.cpp

@@ -121,7 +121,7 @@ class any_diag_reporter {
   }
 
   bool get_error() noexcept {
-    return visit([](auto &r) { return r.found_matching_error(); }, this->tape_);
+    return visit([](auto &r) { return r.found_matching_diag(); }, this->tape_);
   }
 
   void finish() {

src/main.cpp

@@ -178,7 +178,7 @@ void parser::check_jsx_attribute(const identifier& attribute_name) {
 
   if (!name_has_upper && is_event_attribute) {
     bump_vector<char8, monotonic_allocator> fixed_name(
-        "check_jsx_attribute fixed_name", &this->error_memory_);
+        "check_jsx_attribute fixed_name", &this->diagnostic_memory_);
     fixed_name += name;
     fixed_name[2] = toupper(fixed_name[2]);
     this->diag_reporter_->report(diag_jsx_event_attribute_should_be_camel_case{
@@ -266,7 +266,8 @@ expression* parser::maybe_wrap_erroneous_arrow_function(
     if (is_async_arrow_using_with_await_operator) {
       // await (x) => {}   // Invalid.
       // await () => expr  // Invalid.
-      // We treated 'await' as 'async' elsewhere. Don't report any error here.
+      // We treated 'await' as 'async' elsewhere. Don't report any diagnostic
+      // here.
       return arrow_function;
     } else {
       // f() => {}         // Invalid.
@@ -515,9 +516,9 @@ parser_transaction parser::begin_transaction() {
 }
 
 void parser::commit_transaction(parser_transaction&& transaction) {
-  auto* buffered_errors =
+  auto* buffered_diagnostics =
       static_cast<buffering_diag_reporter*>(this->diag_reporter_);
-  buffered_errors->move_into(transaction.old_diag_reporter);
+  buffered_diagnostics->move_into(transaction.old_diag_reporter);
   this->diag_reporter_ = transaction.old_diag_reporter;
 
   this->lexer_.commit_transaction(std::move(transaction.lex_transaction));

src/parse.cpp

@@ -21,7 +21,7 @@ class diag_reporter {
 
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format) \
   void report(name diag) {                                        \
-    this->report_impl(error_type_from_type<name>, &diag);         \
+    this->report_impl(diag_type_from_type<name>, &diag);          \
   }
   QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE

src/quick-lint-js/diag-reporter.h

@@ -1644,7 +1644,7 @@ QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
 template <class Error>
-inline constexpr diag_type error_type_from_type =
+inline constexpr diag_type diag_type_from_type =
     diag_type_from_type_detail<Error>::type;
 
 inline constexpr int diag_type_count = 0

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

@@ -65,7 +65,7 @@ class lexer {
   // template literal (instead of a '}' token, an 'engineer' token, and the
   // beginning of another template literal).
   //
-  // The given template_begin is used for error reporting.
+  // The given template_begin is used for diagnostic reporting.
   //
   // Precondition: this->peek().type == token_type::right_curly
   void skip_in_template(const char8* template_begin);
@@ -118,8 +118,8 @@ class lexer {
   // You can call begin_transaction again before calling commit_transaction
   // or roll_back_transaction. Doing so begins a nested transaction.
   //
-  // Inside a transaction, errors are not reported until commit_transaction is
-  // called for the outer-most nested transaction.
+  // Inside a transaction, diagnostics are not reported until commit_transaction
+  // is called for the outer-most nested transaction.
   lexer_transaction begin_transaction();
 
   // After calling commit_transaction, it's almost as if you never called
@@ -138,13 +138,13 @@ class lexer {
   // roll_back_transaction effectively undoes calls to skip, insert_semicolon,
   // etc.
   //
-  // Calling roll_back_transaction will not report lexer errors which might have
-  // been reported if it weren't for begin_transaction.
+  // Calling roll_back_transaction will not report lexer diagnostics which might
+  // have been reported if it weren't for begin_transaction.
   void roll_back_transaction(lexer_transaction&&);
 
-  // transaction_has_lex_errors can only be called while the given transaction
-  // is the most recent active transaction.
-  bool transaction_has_lex_errors(const lexer_transaction&) const noexcept;
+  // transaction_has_lex_diagnostics can only be called while the given
+  // transaction is the most recent active transaction.
+  bool transaction_has_lex_diagnostics(const lexer_transaction&) const noexcept;
 
   void insert_semicolon();
 
@@ -172,7 +172,7 @@ class lexer {
     token_type type;
     const char8* end;
     // Might be null.
-    buffering_diag_reporter* escape_sequence_errors;
+    buffering_diag_reporter* escape_sequence_diagnostics;
   };
 
   // The result of parsing an identifier.