refactor: rename diag_collector::error -> diag

Author: strager

test/diag-collector.cpp

@@ -19,14 +19,14 @@ void diag_collector::report_impl(diag_type type, void *diag) {
 }
 
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
-  diag_collector::error::error(const name &data)                       \
+  diag_collector::diag::diag(const name &data)                         \
       : type_(diag_type::name), variant_##name##_(std::move(data)) {}
 QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
-diag_type diag_collector::error::type() const noexcept { return this->type_; }
+diag_type diag_collector::diag::type() const noexcept { return this->type_; }
 
-const char *diag_collector::error::error_code() const noexcept {
+const char *diag_collector::diag::error_code() const noexcept {
   switch (this->type_) {
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
   case diag_type::name:                                                \
@@ -37,25 +37,25 @@ const char *diag_collector::error::error_code() const noexcept {
   QLJS_UNREACHABLE();
 }
 
-const void *diag_collector::error::data() const noexcept {
+const void *diag_collector::diag::data() const noexcept {
   return &this->variant_diag_unexpected_token_;  // Arbitrary member.
 }
 
-#define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call)    \
-  template <>                                                             \
-  bool holds_alternative<name>(const diag_collector::error &e) noexcept { \
-    return e.type_ == diag_type::name;                                    \
-  }                                                                       \
-                                                                          \
-  template <>                                                             \
-  const name &get<name>(const diag_collector::error &e) noexcept {        \
-    QLJS_ASSERT(holds_alternative<name>(e));                              \
-    return e.variant_##name##_;                                           \
+#define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call)   \
+  template <>                                                            \
+  bool holds_alternative<name>(const diag_collector::diag &e) noexcept { \
+    return e.type_ == diag_type::name;                                   \
+  }                                                                      \
+                                                                         \
+  template <>                                                            \
+  const name &get<name>(const diag_collector::diag &e) noexcept {        \
+    QLJS_ASSERT(holds_alternative<name>(e));                             \
+    return e.variant_##name##_;                                          \
   }
 QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
-void PrintTo(const diag_collector::error &e, std::ostream *out) {
+void PrintTo(const diag_collector::diag &e, std::ostream *out) {
   *out << e.type_;
 }
 

test/error-matcher.cpp

@@ -193,7 +193,7 @@ error_matcher::error_matcher(padded_string_view input, diag_type type,
     : state_{type, input, {field_0, field_1, field_2}} {}
 
 class error_matcher::impl
-    : public testing::MatcherInterface<const diag_collector::error &> {
+    : public testing::MatcherInterface<const diag_collector::diag &> {
  public:
   explicit impl(state s) : state_(std::move(s)) {}
 
@@ -211,7 +211,7 @@ class error_matcher::impl
     // TODO(strager)
   }
 
-  bool MatchAndExplain(const diag_collector::error &error,
+  bool MatchAndExplain(const diag_collector::diag &error,
                        testing::MatchResultListener *listener) const override {
     bool type_matches = error.type() == this->state_.type;
     if (!type_matches) {
@@ -251,9 +251,8 @@ class error_matcher::impl
 };
 
 /*implicit*/ error_matcher::operator testing::Matcher<
-    const diag_collector::error &>() const {
-  return testing::Matcher<const diag_collector::error &>(
-      new impl(this->state_));
+    const diag_collector::diag &>() const {
+  return testing::Matcher<const diag_collector::diag &>(new impl(this->state_));
 }
 }
 

test/quick-lint-js/diag-collector.h

@@ -17,25 +17,25 @@ namespace quick_lint_js {
 struct diag_collector : public diag_reporter {
   void report_impl(diag_type type, void *diag) override;
 
-  // Like std::variant<(error types)>, but with much faster compilation.
-  class error {
+  // Like std::variant<(diag types)>, but with much faster compilation.
+  class diag {
    public:
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
-  explicit error(const name &);
+  explicit diag(const name &);
     QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 
     diag_type type() const noexcept;
     const char *error_code() const noexcept;
     const void *data() const noexcept;
 
-    template <class Error>
-    friend const Error &get(const error &) noexcept;
+    template <class Diag>
+    friend const Diag &get(const diag &) noexcept;
 
-    template <class Error>
-    friend bool holds_alternative(const error &) noexcept;
+    template <class Diag>
+    friend bool holds_alternative(const diag &) noexcept;
 
-    friend void PrintTo(const error &, std::ostream *);
+    friend void PrintTo(const diag &, std::ostream *);
 
    private:
     diag_type type_;
@@ -47,16 +47,16 @@ struct diag_collector : public diag_reporter {
     };
   };
 
-  std::vector<error> errors;
+  std::vector<diag> errors;
 };
 
-template <class Error>
-const Error &get(const diag_collector::error &) noexcept;
+template <class Diag>
+const Diag &get(const diag_collector::diag &) noexcept;
 
-template <class Error>
-bool holds_alternative(const diag_collector::error &) noexcept;
+template <class Diag>
+bool holds_alternative(const diag_collector::diag &) noexcept;
 
-void PrintTo(const diag_collector::error &, std::ostream *);
+void PrintTo(const diag_collector::diag &, std::ostream *);
 
 #define QLJS_DIAG_TYPE(name, code, severity, struct_body, format_call) \
   void PrintTo(const name &, std::ostream *);

test/quick-lint-js/error-matcher.h

@@ -208,7 +208,7 @@ class error_matcher {
   error_matcher &operator=(const error_matcher &) = default;
   error_matcher &operator=(error_matcher &&) = default;
 
-  /*implicit*/ operator testing::Matcher<const diag_collector::error &>() const;
+  /*implicit*/ operator testing::Matcher<const diag_collector::diag &>() const;
 
  private:
   class impl;

test/quick-lint-js/parse-support.h

@@ -62,7 +62,7 @@ class test_parser {
     return ast;
   }
 
-  const std::vector<diag_collector::error>& errors() const noexcept {
+  const std::vector<diag_collector::diag>& errors() const noexcept {
     return this->errors_.errors;
   }