refactor(fe): use span_size instead of int for object literal sizes

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.0034         +0.0034       2074253       2081328       2074235       2081259
    benchmark_parse_file                       +0.0026         +0.0026       2070954       2076320       2070943       2076303
    benchmark_parse_file                       +0.0005         +0.0005       2069999       2071135       2069965       2071102
    benchmark_parse_file                       -0.0011         -0.0012       2075410       2073025       2075382       2072956
    benchmark_parse_file                       -0.0061         -0.0061       2086029       2073215       2086002       2073176
    benchmark_parse_file                       -0.0033         -0.0032       2080115       2073346       2080054       2073305
    benchmark_parse_file                       -0.0004         -0.0004       2074856       2074118       2074823       2074050
    benchmark_parse_file                       +0.0058         +0.0058       2066870       2078872       2066839       2078835
    benchmark_parse_file                       +0.0064         +0.0064       2065419       2078649       2065359       2078608
    benchmark_parse_file                       +0.0065         +0.0065       2065748       2079127       2065716       2079083
    benchmark_parse_file_pvalue                 0.2413          0.2413      U Test, Repetitions: 10 vs 10
    benchmark_parse_file_mean                  +0.0014         +0.0014       2072965       2075914       2072932       2075868
    benchmark_parse_file_median                +0.0013         +0.0012       2072603       2075219       2072589       2075177
    benchmark_parse_file_stddev                -0.4841         -0.4845          6600          3405          6601          3403
    benchmark_parse_file_cv                    -0.4849         -0.4852             0             0             0             0
    OVERALL_GEOMEAN                            +0.0014         +0.0014             0             0             0             0

Author: strager

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

@@ -270,10 +270,9 @@ class expression {
   // Remove wrapping paren expressions, if any.
   expression *without_paren() const noexcept;
 
-  // TODO(strager): Return span_size instead.
-  int object_entry_count() const noexcept;
+  span_size object_entry_count() const noexcept;
 
-  object_property_value_pair object_entry(int) const noexcept;
+  object_property_value_pair object_entry(span_size) const noexcept;
 
   source_code_span span() const noexcept;
 
@@ -1243,19 +1242,18 @@ inline expression *expression::without_paren() const noexcept {
   return const_cast<expression *>(ast);
 }
 
-inline int expression::object_entry_count() const noexcept {
+inline span_size expression::object_entry_count() const noexcept {
   switch (this->kind_) {
   case expression_kind::object:
-    // TODO(strager): Remove this cast.
-    return narrow_cast<int>(static_cast<const expression::object *>(this)->entries_.size());
+    return static_cast<const expression::object *>(this)->entries_.size();
 
   default:
     QLJS_UNEXPECTED_EXPRESSION_KIND();
   }
 }
 
-inline object_property_value_pair expression::object_entry(int index) const
-    noexcept {
+inline object_property_value_pair expression::object_entry(
+    span_size index) const noexcept {
   switch (this->kind_) {
   case expression_kind::object:
     return static_cast<const expression::object *>(this)->entries_[index];

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

@@ -148,7 +148,7 @@ void parser::visit_expression(expression* ast, parse_visitor_base& v,
     break;
   }
   case expression_kind::object:
-    for (int i = 0; i < ast->object_entry_count(); ++i) {
+    for (span_size i = 0; i < ast->object_entry_count(); ++i) {
       auto entry = ast->object_entry(i);
 
       if (entry.init && entry.is_merged_property_and_value_shorthand()) {
@@ -251,7 +251,7 @@ void parser::maybe_visit_assignment(expression* ast, parse_visitor_base& v) {
     }
     break;
   case expression_kind::object:
-    for (int i = 0; i < ast->object_entry_count(); ++i) {
+    for (span_size i = 0; i < ast->object_entry_count(); ++i) {
       expression* value = ast->object_entry(i).value;
       this->maybe_visit_assignment(value, v);
     }