refactor: rename classes and type aliases to Upper_Snake_Case

See the updates to ADR018.

Author: strager

benchmark/benchmark-cli-location.cpp

@@ -13,11 +13,11 @@ namespace quick_lint_js {
 namespace {
 void benchmark_location_scale_of_long_line(::benchmark::State &state) {
   int line_length = 10'000;
-  padded_string line(string8(narrow_cast<std::size_t>(line_length), u8'x'));
+  Padded_String line(String8(narrow_cast<std::size_t>(line_length), u8'x'));
   for (auto _ : state) {
-    cli_locator l(&line);
+    CLI_Locator l(&line);
     for (int i = 0; i < line_length; ++i) {
-      cli_source_position p = l.position(&line[i]);
+      CLI_Source_Position p = l.position(&line[i]);
       ::benchmark::DoNotOptimize(p);
     }
   }
@@ -26,11 +26,11 @@ BENCHMARK(benchmark_location_scale_of_long_line);
 
 void benchmark_location_scale_of_empty_lines(::benchmark::State &state) {
   int line_count = 10'000;
-  padded_string lines(string8(narrow_cast<std::size_t>(line_count), u8'\n'));
+  Padded_String lines(String8(narrow_cast<std::size_t>(line_count), u8'\n'));
   for (auto _ : state) {
-    cli_locator l(&lines);
+    CLI_Locator l(&lines);
     for (int i = 0; i < line_count; ++i) {
-      cli_source_position p = l.position(&lines[i]);
+      CLI_Source_Position p = l.position(&lines[i]);
       ::benchmark::DoNotOptimize(p);
     }
   }
@@ -40,12 +40,12 @@ BENCHMARK(benchmark_location_scale_of_empty_lines);
 void benchmark_range_scale_of_empty_lines(::benchmark::State &state) {
   int line_length = 10'000;
   int span_length = 5;
-  padded_string line(string8(narrow_cast<std::size_t>(line_length), u8'\n'));
+  Padded_String line(String8(narrow_cast<std::size_t>(line_length), u8'\n'));
   for (auto _ : state) {
-    cli_locator l(&line);
+    CLI_Locator l(&line);
     for (int i = 0; i < line_length - span_length; i += span_length) {
-      source_code_span span(&line[i], &line[i + span_length]);
-      cli_source_range r = l.range(span);
+      Source_Code_Span span(&line[i], &line[i + span_length]);
+      CLI_Source_Range r = l.range(span);
       ::benchmark::DoNotOptimize(r);
     }
   }
@@ -59,9 +59,9 @@ void benchmark_location_realisticish(::benchmark::State &state) {
       /*line_count=*/line_count, /*span_count=*/span_count);
 
   for (auto _ : state) {
-    cli_locator l(code.source.get());
-    for (const source_code_span &span : code.spans) {
-      cli_source_range r = l.range(span);
+    CLI_Locator l(code.source.get());
+    for (const Source_Code_Span &span : code.spans) {
+      CLI_Source_Range r = l.range(span);
       ::benchmark::DoNotOptimize(r);
     }
   }

benchmark/benchmark-configuration-loader.cpp

@@ -26,7 +26,7 @@ void benchmark_no_config_file(::benchmark::State& state) {
   write_file_or_exit(path, u8"");
 
   for (auto _ : state) {
-    configuration_loader loader(basic_configuration_filesystem::instance());
+    Configuration_Loader loader(Basic_Configuration_Filesystem::instance());
     auto config = loader.load_for_file(path);
     ::benchmark::DoNotOptimize(config);
   }

benchmark/benchmark-configuration.cpp

@@ -11,11 +11,11 @@ using namespace std::literals::string_view_literals;
 namespace quick_lint_js {
 namespace {
 void benchmark_parse_config_json(::benchmark::State& state,
-                                 string8_view config_json) {
-  padded_string config_json_string(config_json);
-  null_diag_reporter diag_reporter;
+                                 String8_View config_json) {
+  Padded_String config_json_string(config_json);
+  Null_Diag_Reporter diag_reporter;
 
-  configuration config;
+  Configuration config;
   for (auto _ : state) {
     config.reset();
     config.load_from_json(&config_json_string, &diag_reporter);
@@ -47,7 +47,7 @@ BENCHMARK_CAPTURE(benchmark_parse_config_json, medium_sized,
 )"sv);
 
 void benchmark_config_globals_default(::benchmark::State& state) {
-  configuration config;
+  Configuration config;
   for (auto _ : state) {
     config.reset();
     ::benchmark::DoNotOptimize(config.globals());
@@ -56,7 +56,7 @@ void benchmark_config_globals_default(::benchmark::State& state) {
 BENCHMARK(benchmark_config_globals_default);
 
 void benchmark_config_globals_cleared(::benchmark::State& state) {
-  configuration config;
+  Configuration config;
   for (auto _ : state) {
     config.reset();
     config.reset_global_groups();

benchmark/benchmark-lex.cpp

@@ -9,11 +9,11 @@
 
 namespace quick_lint_js {
 namespace {
-void benchmark_lex(::benchmark::State &state, string8_view raw_source) {
-  padded_string source(raw_source);
+void benchmark_lex(::benchmark::State &state, String8_View raw_source) {
+  Padded_String source(raw_source);
   for (auto _ : state) {
-    lexer l(&source, &null_diag_reporter::instance);
-    while (l.peek().type != token_type::end_of_file) {
+    Lexer l(&source, &Null_Diag_Reporter::instance);
+    while (l.peek().type != Token_Type::end_of_file) {
       l.skip();
     }
     ::benchmark::DoNotOptimize(l.peek().type);

benchmark/benchmark-lint.cpp

@@ -31,18 +31,18 @@ void benchmark_lint(benchmark::State &state) {
                  source_path_env_var);
     std::exit(1);
   }
-  padded_string source = quick_lint_js::read_file_or_exit(source_path);
+  Padded_String source = quick_lint_js::read_file_or_exit(source_path);
 
-  configuration config;
-  parser_options p_options;
-  parser p(&source, &null_diag_reporter::instance, p_options);
-  buffering_visitor visitor(new_delete_resource());
+  Configuration config;
+  Parser_Options p_options;
+  Parser p(&source, &Null_Diag_Reporter::instance, p_options);
+  Buffering_Visitor visitor(new_delete_resource());
   p.parse_and_visit_module(visitor);
 
-  variable_analyzer_options var_options;
+  Variable_Analyzer_Options var_options;
 
   for (auto _ : state) {
-    variable_analyzer l(&null_diag_reporter::instance, &config.globals(),
+    Variable_Analyzer l(&Null_Diag_Reporter::instance, &config.globals(),
                         var_options);
     visitor.copy_into(l);
   }
@@ -61,14 +61,14 @@ void benchmark_parse_and_lint(benchmark::State &state) {
                  source_path_env_var);
     std::exit(1);
   }
-  padded_string source = quick_lint_js::read_file_or_exit(source_path);
+  Padded_String source = quick_lint_js::read_file_or_exit(source_path);
 
-  parser_options p_options;
-  variable_analyzer_options var_options;
-  configuration config;
+  Parser_Options p_options;
+  Variable_Analyzer_Options var_options;
+  Configuration config;
   for (auto _ : state) {
-    parser p(&source, &null_diag_reporter::instance, p_options);
-    variable_analyzer l(&null_diag_reporter::instance, &config.globals(),
+    Parser p(&source, &Null_Diag_Reporter::instance, p_options);
+    Variable_Analyzer l(&Null_Diag_Reporter::instance, &config.globals(),
                         var_options);
     p.parse_and_visit_module(l);
   }
@@ -80,36 +80,36 @@ void benchmark_undeclared_variable_references(benchmark::State &state) {
   int global_variable_count = 1000;
   int variable_use_count = 1000;
 
-  global_declared_variable_set globals;
+  Global_Declared_Variable_Set globals;
   for (int i = 0; i < global_variable_count; ++i) {
     globals.add_predefined_global_variable(
         to_string8("global" + std::to_string(i)).c_str(), /*is_writable=*/true);
   }
 
   std::vector<std::pair<std::size_t, std::size_t>> variable_use_ranges;
-  string8 variable_uses;
+  String8 variable_uses;
   for (int i = 0; i < variable_use_count; ++i) {
     // NOTE(strager): The implementation might short circuit based on identifier
     // length. Use the same prefix so more work needs to be done.
-    string8 variable_name = to_string8("usage_" + std::to_string(i));
+    String8 variable_name = to_string8("usage_" + std::to_string(i));
     std::size_t use_begin = variable_uses.size();
     variable_uses += variable_name;
     std::size_t use_end = variable_uses.size();
     variable_use_ranges.emplace_back(use_begin, use_end);
   }
 
-  std::vector<identifier> variable_use_identifiers;
+  std::vector<Identifier> variable_use_identifiers;
   for (auto [begin_index, end_index] : variable_use_ranges) {
-    const char8 *begin = &variable_uses[begin_index];
-    const char8 *end = &variable_uses[end_index];
-    variable_use_identifiers.emplace_back(source_code_span(begin, end),
+    const Char8 *begin = &variable_uses[begin_index];
+    const Char8 *end = &variable_uses[end_index];
+    variable_use_identifiers.emplace_back(Source_Code_Span(begin, end),
                                           make_string_view(begin, end));
   }
 
-  variable_analyzer_options var_options;
+  Variable_Analyzer_Options var_options;
   for (auto _ : state) {
-    variable_analyzer l(&null_diag_reporter::instance, &globals, var_options);
-    for (identifier &variable_use : variable_use_identifiers) {
+    Variable_Analyzer l(&Null_Diag_Reporter::instance, &globals, var_options);
+    for (Identifier &variable_use : variable_use_identifiers) {
       l.visit_variable_use(variable_use);
     }
     l.visit_end_of_module();

benchmark/benchmark-lsp-document-text.cpp

@@ -16,7 +16,7 @@
 
 namespace quick_lint_js {
 namespace {
-string8_view sentence = u8"The quick brown fox jumps over the lazy dog.";
+String8_View sentence = u8"The quick brown fox jumps over the lazy dog.";
 
 // Simulate opening a document and typing a sentence.
 void benchmark_lsp_create_and_insert_single_characters(
@@ -26,22 +26,22 @@ void benchmark_lsp_create_and_insert_single_characters(
   std::mt19937_64 rng;
   std::vector<int> line_lengths =
       random_line_lengths(rng, /*line_count=*/line_count);
-  padded_string base_code =
+  Padded_String base_code =
       make_source_code(/*line_lengths=*/line_lengths, /*newline=*/u8"\n");
-  string8_view base_code_view = base_code.string_view();
+  String8_View base_code_view = base_code.string_view();
 
   int insertion_line = narrow_cast<int>(line_lengths.size() / 2);
   int initial_insertion_character =
       line_lengths[narrow_cast<std::size_t>(insertion_line)] / 2;
 
   for (auto _ : state) {
-    lsp_document_text doc;
+    LSP_Document_Text doc;
     doc.set_text(base_code_view);
 
     for (int i = 0; i < narrow_cast<int>(sentence.size()); ++i) {
       int insertion_character = initial_insertion_character + i;
       doc.replace_text(
-          lsp_range{
+          LSP_Range{
               .start = {.line = insertion_line,
                         .character = insertion_character},
               .end = {.line = insertion_line, .character = insertion_character},

benchmark/benchmark-lsp-location.cpp

@@ -13,11 +13,11 @@ namespace quick_lint_js {
 namespace {
 void benchmark_location_scale_of_long_line(::benchmark::State &state) {
   int line_length = 10'000;
-  padded_string line(string8(narrow_cast<std::size_t>(line_length), u8'x'));
+  Padded_String line(String8(narrow_cast<std::size_t>(line_length), u8'x'));
   for (auto _ : state) {
-    lsp_locator l(&line);
+    LSP_Locator l(&line);
     for (int i = 0; i < line_length; ++i) {
-      lsp_position p = l.position(&line[i]);
+      LSP_Position p = l.position(&line[i]);
       ::benchmark::DoNotOptimize(p);
     }
   }
@@ -26,11 +26,11 @@ BENCHMARK(benchmark_location_scale_of_long_line);
 
 void benchmark_from_position_scale_of_long_line(::benchmark::State &state) {
   int line_length = 10'000;
-  padded_string line(string8(narrow_cast<std::size_t>(line_length), u8'x'));
+  Padded_String line(String8(narrow_cast<std::size_t>(line_length), u8'x'));
   for (auto _ : state) {
-    lsp_locator l(&line);
+    LSP_Locator l(&line);
     for (int i = 0; i < line_length; ++i) {
-      const char8 *c = l.from_position(lsp_position{.line = 0, .character = i});
+      const Char8 *c = l.from_position(LSP_Position{.line = 0, .character = i});
       ::benchmark::DoNotOptimize(c);
     }
   }
@@ -39,11 +39,11 @@ BENCHMARK(benchmark_from_position_scale_of_long_line);
 
 void benchmark_location_scale_of_empty_lines(::benchmark::State &state) {
   int line_count = 10'000;
-  padded_string lines(string8(narrow_cast<std::size_t>(line_count), u8'\n'));
+  Padded_String lines(String8(narrow_cast<std::size_t>(line_count), u8'\n'));
   for (auto _ : state) {
-    lsp_locator l(&lines);
+    LSP_Locator l(&lines);
     for (int i = 0; i < line_count; ++i) {
-      lsp_position p = l.position(&lines[i]);
+      LSP_Position p = l.position(&lines[i]);
       ::benchmark::DoNotOptimize(p);
     }
   }
@@ -52,11 +52,11 @@ BENCHMARK(benchmark_location_scale_of_empty_lines);
 
 void benchmark_from_position_scale_of_empty_lines(::benchmark::State &state) {
   int line_count = 10'000;
-  padded_string lines(string8(narrow_cast<std::size_t>(line_count), u8'\n'));
+  Padded_String lines(String8(narrow_cast<std::size_t>(line_count), u8'\n'));
   for (auto _ : state) {
-    lsp_locator l(&lines);
+    LSP_Locator l(&lines);
     for (int i = 0; i < line_count; ++i) {
-      const char8 *c = l.from_position({.line = i, .character = 0});
+      const Char8 *c = l.from_position({.line = i, .character = 0});
       ::benchmark::DoNotOptimize(c);
     }
   }
@@ -66,12 +66,12 @@ BENCHMARK(benchmark_from_position_scale_of_empty_lines);
 void benchmark_range_scale_of_empty_lines(::benchmark::State &state) {
   int line_length = 10'000;
   int span_length = 5;
-  padded_string line(string8(narrow_cast<std::size_t>(line_length), u8'\n'));
+  Padded_String line(String8(narrow_cast<std::size_t>(line_length), u8'\n'));
   for (auto _ : state) {
-    lsp_locator l(&line);
+    LSP_Locator l(&line);
     for (int i = 0; i < line_length - span_length; i += span_length) {
-      source_code_span span(&line[i], &line[i + span_length]);
-      lsp_range r = l.range(span);
+      Source_Code_Span span(&line[i], &line[i + span_length]);
+      LSP_Range r = l.range(span);
       ::benchmark::DoNotOptimize(r);
     }
   }
@@ -85,9 +85,9 @@ void benchmark_location_realisticish(::benchmark::State &state) {
       /*line_count=*/line_count, /*span_count=*/span_count);
 
   for (auto _ : state) {
-    lsp_locator l(code.source.get());
-    for (const source_code_span &span : code.spans) {
-      lsp_range r = l.range(span);
+    LSP_Locator l(code.source.get());
+    for (const Source_Code_Span &span : code.spans) {
+      LSP_Range r = l.range(span);
       ::benchmark::DoNotOptimize(r);
     }
   }
@@ -100,20 +100,20 @@ void benchmark_from_position_realisticish(::benchmark::State &state) {
   source_code_with_spans code = make_realisticish_code(
       /*line_count=*/line_count, /*span_count=*/span_count);
 
-  std::vector<lsp_position> positions;
+  std::vector<LSP_Position> positions;
   {
-    lsp_locator l(code.source.get());
-    for (const source_code_span &span : code.spans) {
-      lsp_range r = l.range(span);
+    LSP_Locator l(code.source.get());
+    for (const Source_Code_Span &span : code.spans) {
+      LSP_Range r = l.range(span);
       positions.push_back(r.start);
       positions.push_back(r.end);
     }
   }
 
   for (auto _ : state) {
-    lsp_locator l(code.source.get());
-    for (const lsp_position &position : positions) {
-      const char8 *c = l.from_position(position);
+    LSP_Locator l(code.source.get());
+    for (const LSP_Position &position : positions) {
+      const Char8 *c = l.from_position(position);
       ::benchmark::DoNotOptimize(c);
     }
   }