refactor(fe): use span_size instead of int for child indexes

Reduce narrow_cast-ing.

On x86_64, this seems to have no performance penalty:

    Benchmark                                     Time             CPU      Time Old      Time New       CPU Old       CPU New
    --------------------------------------------------------------------------------------------------------------------------
    benchmark_parse_file                       +0.0013         +0.0013       2093468       2096186       2093456       2096140
    benchmark_parse_file                       -0.0018         -0.0018       2090347       2086606       2090317       2086594
    benchmark_parse_file                       -0.0030         -0.0030       2093381       2087100       2093362       2087045
    benchmark_parse_file                       -0.0038         -0.0038       2095640       2087710       2095594       2087659
    benchmark_parse_file                       -0.0033         -0.0033       2093896       2087037       2093830       2087014
    benchmark_parse_file                       -0.0001         -0.0001       2088977       2088818       2088963       2088754
    benchmark_parse_file                       -0.0040         -0.0040       2094990       2086705       2094951       2086637
    benchmark_parse_file                       -0.0002         -0.0002       2096330       2095965       2096290       2095919
    benchmark_parse_file                       +0.0001         +0.0001       2098723       2098967       2098694       2098919
    benchmark_parse_file                       +0.0001         +0.0001       2097609       2097810       2097591       2097793
    benchmark_parse_file_pvalue                 0.2123          0.2123      U Test, Repetitions: 10 vs 10
    benchmark_parse_file_mean                  -0.0015         -0.0015       2094336       2091290       2094305       2091247
    benchmark_parse_file_median                -0.0030         -0.0030       2094443       2088264       2094391       2088206
    benchmark_parse_file_stddev                +0.7220         +0.7250          3029          5215          3025          5218
    benchmark_parse_file_cv                    +0.7245         +0.7275             0             0             0             0
    OVERALL_GEOMEAN                            -0.0015         -0.0015             0             0             0             0

Author: strager

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

@@ -257,19 +257,20 @@ class expression {
   identifier variable_identifier() const noexcept;
   token_type variable_identifier_token_type() const noexcept;
 
-  int child_count() const noexcept;
+  span_size child_count() const noexcept;
 
   expression *child_0() const noexcept { return this->child(0); }
   expression *child_1() const noexcept { return this->child(1); }
   expression *child_2() const noexcept { return this->child(2); }
 
-  expression *child(int) const noexcept;
+  expression *child(span_size) const noexcept;
 
   expression_arena::array_ptr<expression *> children() const noexcept;
 
   // Remove wrapping paren expressions, if any.
   expression *without_paren() const noexcept;
 
+  // TODO(strager): Return span_size instead.
   int object_entry_count() const noexcept;
 
   object_property_value_pair object_entry(int) const noexcept;
@@ -1127,12 +1128,11 @@ inline token_type expression::variable_identifier_token_type() const noexcept {
   }
 }
 
-inline int expression::child_count() const noexcept {
-  // TODO(strager): Remove this cast.
-  return narrow_cast<int>(this->children().size());
+inline span_size expression::child_count() const noexcept {
+  return this->children().size();
 }
 
-inline expression *expression::child(int index) const noexcept {
+inline expression *expression::child(span_size index) const noexcept {
   return this->children()[index];
 }
 

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

@@ -2237,7 +2237,7 @@ expression* parser::parse_arrow_function_expression_remainder(
     auto* call = expression_cast<expression::call>(parameters_expression);
     if (this->peek().type == token_type::left_curly) {
       parameter_list_begin = call->left_paren_span().begin();
-      for (int i = 1; i < call->child_count(); ++i) {
+      for (span_size i = 1; i < call->child_count(); ++i) {
         parameters.emplace_back(call->child(i));
       }
       // We will report

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

@@ -337,7 +337,7 @@ void parser::error_on_pointless_string_compare(
     return *s == '"' || *s == '\'' || *s == '`';
   };
 
-  for (int i = 0; i < ast->child_count() - 1; i++) {
+  for (span_size i = 0; i < ast->child_count() - 1; i++) {
     expression* lhs = ast->child(i)->without_paren();
     expression* rhs = ast->child(i + 1)->without_paren();
 
@@ -420,7 +420,7 @@ void parser::error_on_pointless_compare_against_literal(
     return s == u8"=="sv || s == u8"==="sv || s == u8"!="sv || s == u8"!=="sv;
   };
 
-  for (int i = 0; i < ast->child_count() - 1; i++) {
+  for (span_size i = 0; i < ast->child_count() - 1; i++) {
     source_code_span op_span = ast->operator_spans_[i];
     if (is_comparison_operator(op_span.string_view())) {
       this->check_compare_against_literal(ast->child(i), ast->child(i + 1),