refactor: rename UpperCamelCase -> Upper_Snake_Case

Change the name of type template parameters to match the style described
in ADR018.

Author: strager

benchmark/benchmark-lsp/lsp-server-process.cpp

@@ -304,21 +304,21 @@ LSP_Server_Process::wait_for_diagnostics_ignoring_async(
       /*messages_to_ignore=*/messages_to_ignore);
 }
 
-template <class ParamsPredicate>
+template <class Params_Predicate>
 LSP_Task<::boost::json::array> LSP_Server_Process::wait_for_diagnostics_async(
-    ParamsPredicate&& predicate) {
+    Params_Predicate&& predicate) {
   return this->wait_for_diagnostics_ignoring_async(
-      std::forward<ParamsPredicate>(predicate),
+      std::forward<Params_Predicate>(predicate),
       /*messages_to_ignore=*/this->diagnostics_messages_to_ignore_);
 }
 
-template <class ParamsPredicate>
+template <class Params_Predicate>
 LSP_Task<::boost::json::array>
 LSP_Server_Process::wait_for_diagnostics_ignoring_async(
-    ParamsPredicate&& predicate, std::int64_t messages_to_ignore) {
+    Params_Predicate&& predicate, std::int64_t messages_to_ignore) {
   ::boost::json::object notification =
       co_await this->wait_for_diagnostics_notification_async(
-          std::forward<ParamsPredicate>(predicate),
+          std::forward<Params_Predicate>(predicate),
           /*messages_to_ignore=*/messages_to_ignore);
   co_return look_up(notification, "params", "diagnostics").get_array();
 }
@@ -329,19 +329,19 @@ LSP_Server_Process::wait_for_diagnostics_notification_async() {
       []([[maybe_unused]] ::boost::json::object& params) { return true; });
 }
 
-template <class ParamsPredicate>
+template <class Params_Predicate>
 LSP_Task<::boost::json::object>
 LSP_Server_Process::wait_for_diagnostics_notification_async(
-    ParamsPredicate&& predicate) {
+    Params_Predicate&& predicate) {
   return this->wait_for_diagnostics_notification_async(
-      std::forward<ParamsPredicate>(predicate),
+      std::forward<Params_Predicate>(predicate),
       /*messages_to_ignore=*/this->diagnostics_messages_to_ignore_);
 }
 
-template <class ParamsPredicate>
+template <class Params_Predicate>
 LSP_Task<::boost::json::object>
 LSP_Server_Process::wait_for_diagnostics_notification_async(
-    ParamsPredicate&& predicate, std::int64_t messages_to_ignore) {
+    Params_Predicate&& predicate, std::int64_t messages_to_ignore) {
   for (std::int64_t i = 0; i < messages_to_ignore; ++i) {
     co_await this->wait_for_first_diagnostics_notification_async(predicate);
   }
@@ -355,10 +355,10 @@ LSP_Server_Process::wait_for_first_diagnostics_notification_async() {
       []([[maybe_unused]] ::boost::json::object& params) { return true; });
 }
 
-template <class ParamsPredicate>
+template <class Params_Predicate>
 LSP_Task<::boost::json::object>
 LSP_Server_Process::wait_for_first_diagnostics_notification_async(
-    ParamsPredicate&& predicate) {
+    Params_Predicate&& predicate) {
   for (;;) {
     ::boost::json::object message =
         (co_await this->get_message_async()).as_object();

benchmark/benchmark-lsp/quick-lint-js/lsp-server-process.h

@@ -253,30 +253,30 @@ class LSP_Server_Process {
       std::int64_t document_version, std::int64_t messages_to_ignore);
   LSP_Task<::boost::json::array> wait_for_diagnostics_async(
       String8_View document_uri, std::int64_t document_version);
-  template <class ParamsPredicate>
-  LSP_Task<::boost::json::array> wait_for_diagnostics_async(ParamsPredicate&&);
-  template <class ParamsPredicate>
+  template <class Params_Predicate>
+  LSP_Task<::boost::json::array> wait_for_diagnostics_async(Params_Predicate&&);
+  template <class Params_Predicate>
   LSP_Task<::boost::json::array> wait_for_diagnostics_ignoring_async(
-      ParamsPredicate&&, std::int64_t messages_to_ignore);
+      Params_Predicate&&, std::int64_t messages_to_ignore);
 
   // Returns the entire notification object.
   // Respects diagnosticsMessagesToIgnore.
   LSP_Task<::boost::json::object> wait_for_diagnostics_notification_async();
-  template <class ParamsPredicate>
+  template <class Params_Predicate>
   LSP_Task<::boost::json::object> wait_for_diagnostics_notification_async(
-      ParamsPredicate&&);
-  template <class ParamsPredicate>
+      Params_Predicate&&);
+  template <class Params_Predicate>
   LSP_Task<::boost::json::object> wait_for_diagnostics_notification_async(
-      ParamsPredicate&&, std::int64_t messages_to_ignore);
+      Params_Predicate&&, std::int64_t messages_to_ignore);
 
   // Returns the entire notification object.
   // Does not respect diagnosticsMessagesToIgnore; returns the first matching
   // message.
   LSP_Task<::boost::json::object>
   wait_for_first_diagnostics_notification_async();
-  template <class ParamsPredicate>
+  template <class Params_Predicate>
   LSP_Task<::boost::json::object> wait_for_first_diagnostics_notification_async(
-      ParamsPredicate&&);
+      Params_Predicate&&);
 
   void send_message(Byte_Buffer&& message);
 

src/quick-lint-js/container/async-byte-queue.h

@@ -66,9 +66,9 @@ class Async_Byte_Queue {
   String8 take_committed_string8();
 
   // Reader thread only.
-  template <class ChunkFunc, class FinalizeFunc>
-  void take_committed(ChunkFunc&& chunk_callback,
-                      FinalizeFunc&& finalize_callback);
+  template <class Chunk_Func, class Finalize_Func>
+  void take_committed(Chunk_Func&& chunk_callback,
+                      Finalize_Func&& finalize_callback);
 
  private:
   struct alignas(alignof(Max_Align_T)) Chunk {
@@ -143,9 +143,9 @@ class Async_Byte_Queue {
 };
 
 // Reader thread only.
-template <class ChunkFunc, class FinalizeFunc>
-void Async_Byte_Queue::take_committed(ChunkFunc&& chunk_callback,
-                                      FinalizeFunc&& finalize_callback) {
+template <class Chunk_Func, class Finalize_Func>
+void Async_Byte_Queue::take_committed(Chunk_Func&& chunk_callback,
+                                      Finalize_Func&& finalize_callback) {
   Chunk* first_chunk = this->reader_chunk_;
   Chunk* last_chunk;
   {

src/quick-lint-js/container/heap-function.h

@@ -8,7 +8,7 @@
 #include <utility>
 
 namespace quick_lint_js {
-template <class FuncType>
+template <class Func_Type>
 class Heap_Function;
 
 // heap_function is like std::function but with a few differences:

src/quick-lint-js/container/vector.h

@@ -86,11 +86,11 @@ class Uninstrumented_Vector : private Vector {
 
 using Bump_Vector_Size = std::ptrdiff_t;
 
-template <class T, class BumpAllocator>
+template <class T, class Bump_Allocator>
 class Raw_Bump_Vector {
  public:
   using value_type = T;
-  using allocator_type = BumpAllocator *;
+  using allocator_type = Bump_Allocator *;
   using size_type = Bump_Vector_Size;
   using difference_type = Bump_Vector_Size;
   using reference = T &;
@@ -102,7 +102,7 @@ class Raw_Bump_Vector {
 
   static_assert(is_winkable_v<T>);
 
-  explicit Raw_Bump_Vector(BumpAllocator *allocator) noexcept
+  explicit Raw_Bump_Vector(Bump_Allocator *allocator) noexcept
       : allocator_(allocator) {}
 
   Raw_Bump_Vector(const Raw_Bump_Vector &) = delete;
@@ -120,7 +120,7 @@ class Raw_Bump_Vector {
 
   ~Raw_Bump_Vector() { this->clear(); }
 
-  BumpAllocator *get_allocator() const noexcept { return this->allocator_; }
+  Bump_Allocator *get_allocator() const noexcept { return this->allocator_; }
 
   bool empty() const noexcept { return this->data_ == this->data_end_; }
   size_type size() const noexcept {
@@ -300,15 +300,15 @@ class Raw_Bump_Vector {
   T *data_end_ = nullptr;
   T *capacity_end_ = nullptr;
 
-  BumpAllocator *allocator_;
+  Bump_Allocator *allocator_;
 };
 
 #if QLJS_FEATURE_VECTOR_PROFILING
-template <class T, class BumpAllocator>
-using Bump_Vector = Instrumented_Vector<Raw_Bump_Vector<T, BumpAllocator>>;
+template <class T, class Bump_Allocator>
+using Bump_Vector = Instrumented_Vector<Raw_Bump_Vector<T, Bump_Allocator>>;
 #else
-template <class T, class BumpAllocator>
-using Bump_Vector = Uninstrumented_Vector<Raw_Bump_Vector<T, BumpAllocator>>;
+template <class T, class Bump_Allocator>
+using Bump_Vector = Uninstrumented_Vector<Raw_Bump_Vector<T, Bump_Allocator>>;
 #endif
 }
 

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

@@ -97,7 +97,7 @@ const Diagnostic_Info &get_diagnostic_info(Diag_Type) noexcept;
 std::optional<Diag_Type> diag_type_from_code_slow(
     std::string_view code) noexcept;
 
-template <class ArgType>
+template <class Arg_Type>
 constexpr Diagnostic_Arg_Type get_diagnostic_message_arg_type() noexcept;
 template <>
 constexpr Diagnostic_Arg_Type

src/quick-lint-js/fe/parse.cpp

@@ -707,7 +707,7 @@ void Parser::check_body_after_label() {
   this->error_on_lexical_declaration(Statement_Kind::labelled_statement);
 }
 
-template <class MissingSemicolonDiagnostic>
+template <class Missing_Semicolon_Diagnostic>
 void Parser::consume_semicolon() {
   switch (this->peek().type) {
   case Token_Type::semicolon:
@@ -723,7 +723,7 @@ void Parser::consume_semicolon() {
     } else {
       this->lexer_.insert_semicolon();
       this->diag_reporter_->report(
-          MissingSemicolonDiagnostic{this->peek().span()});
+          Missing_Semicolon_Diagnostic{this->peek().span()});
       this->skip();
     }
     break;

src/quick-lint-js/fe/parse.h

@@ -446,7 +446,7 @@ class Parser {
 
   void parse_and_visit_with(Parse_Visitor_Base &v);
 
-  template <class ExpectedParenthesesError, class ExpectedParenthesisError,
+  template <class Expected_Parentheses_Error, class Expected_Parenthesis_Error,
             bool CheckForSketchyConditions, bool CheckForCommaOperator>
   void parse_and_visit_parenthesized_expression(Parse_Visitor_Base &v,
                                                 Source_Code_Span token);
@@ -749,7 +749,7 @@ class Parser {
                                                   Expression *lhs);
 
   void consume_semicolon_after_statement();
-  template <class MissingSemicolonDiagnostic>
+  template <class Missing_Semicolon_Diagnostic>
   void consume_semicolon();
 
   void error_on_pointless_nullish_coalescing_operator(
@@ -808,8 +808,8 @@ class Parser {
   //
   // When try_func and catch_func are called, they start with the same lexer
   // state.
-  template <class TryFunc, class CatchFunc>
-  void try_parse(TryFunc &&try_func, CatchFunc &&catch_func) {
+  template <class Try_Func, class Catch_Func>
+  void try_parse(Try_Func &&try_func, Catch_Func &&catch_func) {
     Parser_Transaction transaction = this->begin_transaction();
     bool should_commit = std::move(try_func)();
     if (should_commit) {
@@ -1078,7 +1078,7 @@ class Parser {
       Parse_Visitor_Base &v, const TypeScript_Declare_Context &declare_context);
 };
 
-template <class ExpectedParenthesesError, class ExpectedParenthesisError,
+template <class Expected_Parentheses_Error, class Expected_Parenthesis_Error,
           bool CheckForSketchyConditions, bool CheckForCommaOperator>
 void Parser::parse_and_visit_parenthesized_expression(
     Parse_Visitor_Base &v, Source_Code_Span token_span) {
@@ -1116,15 +1116,15 @@ void Parser::parse_and_visit_parenthesized_expression(
   }
 
   if (!have_expression_left_paren && !have_expression_right_paren) {
-    this->diag_reporter_->report(ExpectedParenthesesError{
+    this->diag_reporter_->report(Expected_Parentheses_Error{
         Source_Code_Span(expression_begin, expression_end)});
   } else if (!have_expression_right_paren) {
-    this->diag_reporter_->report(ExpectedParenthesisError{
+    this->diag_reporter_->report(Expected_Parenthesis_Error{
         .where = Source_Code_Span::unit(expression_end),
         .token = ')',
     });
   } else if (!have_expression_left_paren) {
-    this->diag_reporter_->report(ExpectedParenthesisError{
+    this->diag_reporter_->report(Expected_Parenthesis_Error{
         .where = Source_Code_Span::unit(expression_begin),
         .token = '(',
     });

src/quick-lint-js/fe/variable-analyzer.cpp

@@ -852,12 +852,12 @@ void Variable_Analyzer::report_error_if_assignment_is_illegal(
   }
 }
 
-template <class DeclaredVariableType>
+template <class Declared_Variable_Type>
 void Variable_Analyzer::report_errors_for_variable_use(
-    const Used_Variable &used_var, const DeclaredVariableType &declared,
+    const Used_Variable &used_var, const Declared_Variable_Type &declared,
     bool use_is_before_declaration) const {
   constexpr bool declared_in_global_scope =
-      std::is_same_v<DeclaredVariableType, Global_Declared_Variable>;
+      std::is_same_v<Declared_Variable_Type, Global_Declared_Variable>;
 
   if (used_var.kind == Used_Variable_Kind::assignment) {
     this->report_error_if_assignment_is_illegal(

src/quick-lint-js/fe/variable-analyzer.h

@@ -279,9 +279,9 @@ class Variable_Analyzer final : public Parse_Visitor_Base {
       const Identifier *declaration, const Identifier &assignment,
       bool is_assigned_before_declaration) const;
 
-  template <class DeclaredVariableType>
+  template <class Declared_Variable_Type>
   void report_errors_for_variable_use(const Used_Variable &,
-                                      const DeclaredVariableType &,
+                                      const Declared_Variable_Type &,
                                       bool use_is_before_declaration) const;
 
   void report_error_if_variable_declaration_conflicts_in_scope(