refactor(fe): add array->span conversion to simplify code

Author: strager

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

@@ -1146,9 +1146,7 @@ inline expression_arena::array_ptr<expression *> expression::children() const
   case expression_kind::compound_assignment:
   case expression_kind::conditional_assignment: {
     auto *assignment = static_cast<const expression::assignment *>(this);
-    return expression_arena::array_ptr<expression *>(
-        assignment->children_.data(),
-        narrow_cast<int>(assignment->children_.size()));
+    return expression_arena::array_ptr<expression *>(assignment->children_);
   }
 
   case expression_kind::_delete:
@@ -1196,18 +1194,15 @@ inline expression_arena::array_ptr<expression *> expression::children() const
     return static_cast<const expression::call *>(this)->children_;
   case expression_kind::conditional: {
     auto *conditional = static_cast<const expression::conditional *>(this);
-    return expression_arena::array_ptr<expression *>(
-        conditional->children_.data(),
-        narrow_cast<int>(conditional->children_.size()));
+    return expression_arena::array_ptr<expression *>(conditional->children_);
   }
   case expression_kind::dot: {
     auto *dot = static_cast<const expression::dot *>(this);
     return expression_arena::array_ptr<expression *>(&dot->child_, 1);
   }
   case expression_kind::index: {
     auto *index = static_cast<const expression::index *>(this);
-    return expression_arena::array_ptr<expression *>(
-        index->children_.data(), narrow_cast<int>(index->children_.size()));
+    return expression_arena::array_ptr<expression *>(index->children_);
   }
   case expression_kind::non_null_assertion: {
     auto *assertion = static_cast<const expression::non_null_assertion *>(this);

src/quick-lint-js/port/span.h

@@ -27,6 +27,10 @@ class span {
 
   explicit span() noexcept : data_(nullptr), size_(0) {}
 
+  template <std::size_t N>
+  explicit span(const std::array<std::remove_const_t<T>, N> &data) noexcept
+      : data_(data.data()), size_(N) {}
+
   explicit span(T *data, size_type size) noexcept : data_(data), size_(size) {}
 
   explicit span(T *begin, T *end) noexcept