Add a static extent template parameter to absl::Span

`absl::Span<T, N>` refers to exactly N elements and stores only a
pointer. `absl::Span<T>` is now shorthand for
`absl::Span<T, absl::dynamic_extent>` and behaves as before.

PiperOrigin-RevId: 1016273879
diff --git a/absl/algorithm/container.h b/absl/algorithm/container.h
index 1db7da7..7af0a57 100644
--- a/absl/algorithm/container.h
+++ b/absl/algorithm/container.h
@@ -65,7 +65,7 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-template <typename T>
+template <typename T, size_t Extent>
 class Span;
 
 namespace container_algorithm_internal {
@@ -201,8 +201,8 @@
     : std::conditional_t<std::is_same_v<T, std::remove_cv_t<T>>,
                          std::false_type, IsSpan<std::remove_cv_t<T>>> {};
 
-template <typename T>
-struct IsSpan<absl::Span<T>> : std::true_type {};
+template <typename T, size_t Extent>
+struct IsSpan<absl::Span<T, Extent>> : std::true_type {};
 
 #ifdef __cpp_lib_span
 template <typename T, size_t Extent>
diff --git a/absl/types/internal/span.h b/absl/types/internal/span.h
index f0f1af6..f6dec27 100644
--- a/absl/types/internal/span.h
+++ b/absl/types/internal/span.h
@@ -17,6 +17,7 @@
 #define ABSL_TYPES_INTERNAL_SPAN_H_
 
 #include <algorithm>
+#include <array>
 #include <cstddef>
 #include <string>
 #include <type_traits>
@@ -28,7 +29,7 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-template <typename T>
+template <typename T, size_t Extent>
 class Span;
 
 namespace span_internal {
@@ -78,17 +79,17 @@
 template <typename T>
 using EnableIfMutable = std::enable_if_t<!std::is_const_v<T>, int>;
 
-template <template <typename> class SpanT, typename T>
-constexpr bool EqualImpl(SpanT<T> a, SpanT<T> b) {
-  static_assert(std::is_const_v<T>);
+template <typename SpanT>
+constexpr bool EqualImpl(SpanT a, SpanT b) {
+  static_assert(std::is_const_v<typename SpanT::element_type>);
   return std::equal(a.begin(), a.end(), b.begin(), b.end());
 }
 
-template <template <typename> class SpanT, typename T>
-constexpr bool LessThanImpl(SpanT<T> a, SpanT<T> b) {
+template <typename SpanT>
+constexpr bool LessThanImpl(SpanT a, SpanT b) {
   // We can't use value_type since that is remove_cv_t<T>, so we go the long way
   // around.
-  static_assert(std::is_const_v<T>);
+  static_assert(std::is_const_v<typename SpanT::element_type>);
   return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
 }
 
@@ -125,6 +126,20 @@
 template <typename T>
 using EnableIfNotIsView = std::enable_if_t<!IsView<T>::value, int>;
 
+// Detect `Span` and `std::array`, which static-extent spans convert from with
+// dedicated constructors.
+template <typename T>
+struct IsSpan : std::false_type {};
+
+template <typename T, size_t Extent>
+struct IsSpan<Span<T, Extent>> : std::true_type {};
+
+template <typename T>
+struct IsStdArray : std::false_type {};
+
+template <typename T, size_t N>
+struct IsStdArray<std::array<T, N>> : std::true_type {};
+
 }  // namespace span_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/absl/types/span.h b/absl/types/span.h
index 41aba0a..4b4bcb9 100644
--- a/absl/types/span.h
+++ b/absl/types/span.h
@@ -42,8 +42,10 @@
 //      assignment.
 //    * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or
 //      `as_writable_bytes()` methods
-//    * `absl::Span` has no static extent template parameter, nor constructors
-//      which exist only because of the static extent parameter.
+//    * `absl::Span<T, N>` supports a static extent like `std::span<T, N>`, but
+//      class template argument deduction and `MakeSpan()` always produce
+//      dynamic-extent spans, and static-extent spans have no relational
+//      operators of their own.
 //    * `absl::Span` has an explicit mutable-reference constructor
 //    * `absl::Span::subspan(pos, len)` always truncates `len` to
 //      `size() - pos`, whereas `std::span::subspan()` only truncates when the
@@ -54,6 +56,7 @@
 #define ABSL_TYPES_SPAN_H_
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstddef>
 #include <initializer_list>
@@ -76,7 +79,13 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-template <typename T>
+// dynamic_extent
+//
+// The extent of a `Span` whose size is only known at runtime.
+// `absl::Span<T>` is shorthand for `absl::Span<T, absl::dynamic_extent>`.
+inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
+
+template <typename T, size_t Extent = dynamic_extent>
 class Span;
 
 ABSL_NAMESPACE_END
@@ -89,12 +98,13 @@
 #endif
 #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
 #include <ranges>  // NOLINT(build/c++20)
-template <typename T>
+template <typename T, size_t Extent>
 // NOLINTNEXTLINE(build/c++20)
-inline constexpr bool std::ranges::enable_view<absl::Span<T>> = true;
-template <typename T>
+inline constexpr bool std::ranges::enable_view<absl::Span<T, Extent>> = true;
+template <typename T, size_t Extent>
 // NOLINTNEXTLINE(build/c++20)
-inline constexpr bool std::ranges::enable_borrowed_range<absl::Span<T>> = true;
+inline constexpr bool
+    std::ranges::enable_borrowed_range<absl::Span<T, Extent>> = true;
 #endif
 
 namespace absl {
@@ -178,8 +188,24 @@
 //   // Explicit constructor from pointer,size
 //   int* my_array = new int[10];
 //   MyRoutine(absl::Span<const int>(my_array, 10));
+//
+// Static extents
+//
+// `Span<T, N>` refers to exactly `N` elements, like `std::span<T, N>`. Only
+// conversions that cannot change the size are implicit:
+//
+//   void SetKey(absl::Span<const uint8_t, 32> key);
+//
+//   std::array<uint8_t, 32> key = ...;
+//   SetKey(key);                                     // OK, implicit
+//   absl::Span<const uint8_t> dynamic = key;         // OK, implicit
+//   SetKey(absl::Span<const uint8_t, 32>(dynamic));  // explicit, size checked
+//   SetKey(dynamic.first<32>());                     // explicit, size checked
+//
+// The `Span<T>` documented below is the dynamic-extent case,
+// `Span<T, dynamic_extent>`. The static-extent case is defined after it.
 template <typename T>
-class ABSL_ATTRIBUTE_VIEW Span {
+class ABSL_ATTRIBUTE_VIEW Span<T, dynamic_extent> {
  private:
   // Used to determine whether a Span can be constructed from a container of
   // type C.
@@ -217,6 +243,7 @@
 
   // NOLINTNEXTLINE
   static constexpr size_type npos = static_cast<size_type>(-1);
+  static constexpr size_type extent = dynamic_extent;
 
   constexpr Span() noexcept : Span(nullptr, 0) {}
   constexpr Span(pointer array ABSL_ATTRIBUTE_LIFETIME_BOUND,
@@ -303,6 +330,16 @@
            ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/explicit)
       : Span(v.begin(), v.size()) {}
 
+  // Implicit conversion from a static-extent span, e.g. from `Span<int, 4>` to
+  // `Span<int>` or `Span<const int>`.
+  template <typename U, size_t N,
+            std::enable_if_t<N != dynamic_extent &&
+                                 std::is_convertible_v<U (*)[], T (*)[]>,
+                             int> = 0>
+  constexpr Span(  // NOLINT(google-explicit-constructor)
+      Span<U, N> other) noexcept
+      : Span(other.data(), N) {}
+
   // Accessors
 
   // Span::data()
@@ -495,6 +532,40 @@
                            : (ThrowStdOutOfRange("len > size()"), Span());
   }
 
+  // Span::first<Count>(), Span::last<Count>(), Span::subspan<Offset, Count>()
+  //
+  // Like `first()`, `last()` and `subspan()` above, but return a static-extent
+  // `Span<T, Count>`. Unlike `subspan(pos, len)`, `subspan<Offset, Count>()`
+  // never truncates: `Offset + Count` must be <= size(). Without a `Count`, the
+  // result is a dynamic-extent span holding the rest of the elements.
+  //
+  // Examples:
+  //
+  //   std::vector<int> vec = {10, 11, 12, 13};
+  //   absl::MakeSpan(vec).first<2>();       // Span<int, 2>{10, 11}
+  //   absl::MakeSpan(vec).last<1>();        // Span<int, 1>{13}
+  //   absl::MakeSpan(vec).subspan<1, 2>();  // Span<int, 2>{11, 12}
+  //   absl::MakeSpan(vec).subspan<1>();     // Span<int>{11, 12, 13}
+  //   absl::MakeSpan(vec).first<5>();       // throws std::out_of_range
+  template <size_t Count>
+  constexpr Span<T, Count> first() const {
+    return Span<T, Count>(first(Count));
+  }
+
+  template <size_t Count>
+  constexpr Span<T, Count> last() const {
+    return Span<T, Count>(last(Count));
+  }
+
+  template <size_t Offset, size_t Count = dynamic_extent>
+  constexpr Span<T, Count> subspan() const {
+    if constexpr (Count == dynamic_extent) {
+      return subspan(Offset);
+    } else {
+      return subspan(Offset).template first<Count>();
+    }
+  }
+
   // Support for absl::Hash.
   template <typename H>
   friend H AbslHashValue(H h, Span v) {
@@ -506,6 +577,220 @@
   size_type len_;
 };
 
+//------------------------------------------------------------------------------
+// Span<T, Extent>
+//------------------------------------------------------------------------------
+//
+// A `Span` with a static extent refers to exactly `Extent` elements. The size
+// is part of the type, so the span only stores a pointer.
+//
+// Construction:
+//
+//   * Implicitly from `T[Extent]`, `std::array<U, Extent>` and
+//     `Span<U, Extent>`, where `U*` converts to `T*` by adding qualifiers.
+//   * Explicitly from a dynamic-extent `Span<U>`, from a pointer and size, and
+//     from containers that `Span<T>` can be constructed from. The size must
+//     equal `Extent`, which is checked by Abseil hardening.
+//
+// A static-extent span converts implicitly to `Span<T>`. There are no
+// relational operators between two static-extent spans.
+template <typename T, size_t Extent>
+class ABSL_ATTRIBUTE_VIEW Span {
+ private:
+  // SFINAE-enables a conversion from `U*` to `T*` that only adds qualifiers.
+  // Unlike `std::is_convertible_v<U*, T*>`, this rejects derived-to-base.
+  template <typename U>
+  using EnableIfCompatible =
+      std::enable_if_t<std::is_convertible_v<U (*)[], T (*)[]>, int>;
+
+  template <typename V>
+  using RemoveCvRef = std::remove_cv_t<std::remove_reference_t<V>>;
+
+  // SFINAE-enables construction from the containers that `Span<T>` can be
+  // constructed from, except pointers, arrays and spans. Those have dedicated
+  // constructors, so that a size mismatch is a compile-time error.
+  template <typename V>
+  using EnableIfContainer =
+      std::enable_if_t<!std::is_pointer_v<RemoveCvRef<V>> &&
+                           !std::is_array_v<RemoveCvRef<V>> &&
+                           !span_internal::IsStdArray<RemoveCvRef<V>>::value &&
+                           !span_internal::IsSpan<RemoveCvRef<V>>::value &&
+                           std::is_constructible_v<Span<T>, V>,
+                       int>;
+
+ public:
+  using element_type = T;
+  using value_type = std::remove_cv_t<T>;
+  using pointer = T* absl_nullability_unknown;
+  using const_pointer = const T* absl_nullability_unknown;
+  using reference = T&;
+  using const_reference = const T&;
+  using iterator = pointer;
+  using const_iterator = const_pointer;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using absl_internal_is_view = std::true_type;
+
+  // NOLINTNEXTLINE
+  static constexpr size_type npos = static_cast<size_type>(-1);
+  static constexpr size_type extent = Extent;
+
+  // Only spans of zero elements are default-constructible.
+  template <size_t E = Extent, std::enable_if_t<E == 0, int> = 0>
+  constexpr Span() noexcept : ptr_(nullptr) {}
+
+  // Explicit constructor from a pointer and size. `length` must equal `Extent`.
+  constexpr explicit Span(pointer array ABSL_ATTRIBUTE_LIFETIME_BOUND,
+                          size_type length) noexcept
+      : ptr_(array) {
+    absl::base_internal::HardeningAssert(length == Extent);
+  }
+
+  // Implicit conversion constructors from arrays of exactly `Extent` elements.
+  constexpr Span(  // NOLINT(google-explicit-constructor)
+      T (&a ABSL_ATTRIBUTE_LIFETIME_BOUND)[Extent]) noexcept
+      : ptr_(a) {}
+
+  template <typename U, EnableIfCompatible<U> = 0>
+  constexpr Span(  // NOLINT(google-explicit-constructor)
+      std::array<U, Extent>& a ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : ptr_(a.data()) {}
+
+  template <typename U, EnableIfCompatible<const U> = 0>
+  constexpr Span(  // NOLINT(google-explicit-constructor)
+      const std::array<U, Extent>& a ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : ptr_(a.data()) {}
+
+  // Implicit conversion from a span with the same extent, e.g. from
+  // `Span<int, 4>` to `Span<const int, 4>`.
+  template <typename U, EnableIfCompatible<U> = 0,
+            std::enable_if_t<!std::is_same_v<U, T>, int> = 0>
+  constexpr Span(  // NOLINT(google-explicit-constructor)
+      Span<U, Extent> other) noexcept
+      : ptr_(other.data()) {}
+
+  // Explicit conversion from a dynamic-extent span. `other.size()` must equal
+  // `Extent`.
+  template <typename U, EnableIfCompatible<U> = 0>
+  constexpr explicit Span(Span<U> other) noexcept
+      : Span(other.data(), other.size()) {}
+
+  // Explicit conversion from a container. `v.size()` must equal `Extent`. As
+  // with `Span<T>`, a span of mutable elements needs a mutable container.
+  template <typename V, EnableIfContainer<V> = 0,
+            span_internal::EnableIfNotIsView<RemoveCvRef<V>> = 0>
+  constexpr explicit Span(V&& v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      : Span(Span<T>(std::forward<V>(v))) {}
+
+  // Overload of the above for view types, without the lifetime annotation.
+  template <typename V, EnableIfContainer<V> = 0,
+            span_internal::EnableIfIsView<RemoveCvRef<V>> = 0>
+  constexpr explicit Span(V&& v) noexcept : Span(Span<T>(std::forward<V>(v))) {}
+
+  // Accessors. See the dynamic-extent `Span<T>` above for documentation.
+
+  constexpr pointer data() const noexcept { return ptr_; }
+  constexpr size_type size() const noexcept { return Extent; }
+  constexpr size_type length() const noexcept { return size(); }
+  constexpr bool empty() const noexcept { return Extent == 0; }
+
+  constexpr reference operator[](size_type i) const noexcept {
+    absl::base_internal::HardeningAssertLT(i, size());
+    return ptr_[i];
+  }
+
+  constexpr reference at(size_type i) const {
+    return ABSL_PREDICT_TRUE(i < size())  //
+               ? *(data() + i)
+               : (ThrowStdOutOfRange("Span::at failed bounds check"),
+                  *(data() + i));
+  }
+
+  // Unlike for `Span<T>`, calling `front()` or `back()` on a span of zero
+  // elements is a compile-time error.
+  constexpr reference front() const noexcept {
+    static_assert(Extent > 0, "front() requires a non-empty span");
+    return *data();
+  }
+
+  constexpr reference back() const noexcept {
+    static_assert(Extent > 0, "back() requires a non-empty span");
+    return *(data() + (Extent - 1));
+  }
+
+  constexpr iterator begin() const noexcept { return data(); }
+  constexpr const_iterator cbegin() const noexcept { return begin(); }
+  constexpr iterator end() const noexcept { return data() + Extent; }
+  constexpr const_iterator cend() const noexcept { return end(); }
+  constexpr reverse_iterator rbegin() const noexcept {
+    return reverse_iterator(end());
+  }
+  constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+  constexpr reverse_iterator rend() const noexcept {
+    return reverse_iterator(begin());
+  }
+  constexpr const_reverse_iterator crend() const noexcept { return rend(); }
+
+  // Span::first<Count>(), Span::last<Count>(), Span::subspan<Offset, Count>()
+  //
+  // Static-extent subspans. Out-of-range arguments are compile-time errors.
+  template <size_t Count>
+  constexpr Span<T, Count> first() const noexcept {
+    static_assert(Count <= Extent, "Count must not exceed the extent");
+    return Span<T, Count>(data(), Count);
+  }
+
+  template <size_t Count>
+  constexpr Span<T, Count> last() const noexcept {
+    static_assert(Count <= Extent, "Count must not exceed the extent");
+    return Span<T, Count>(data() + (Extent - Count), Count);
+  }
+
+  template <size_t Offset, size_t Count = dynamic_extent>
+  constexpr auto subspan() const noexcept {
+    static_assert(Offset <= Extent, "Offset must not exceed the extent");
+    static_assert(Count == dynamic_extent || Count <= Extent - Offset,
+                  "Offset + Count must not exceed the extent");
+    constexpr size_type kCount =
+        Count == dynamic_extent ? Extent - Offset : Count;
+    return Span<T, kCount>(data() + Offset, kCount);
+  }
+
+  // Span::first(), Span::last(), Span::subspan()
+  //
+  // Dynamic-extent subspans, with the same semantics as for `Span<T>`.
+  constexpr Span<T> first(size_type len) const {
+    return Span<T>(*this).first(len);
+  }
+
+  constexpr Span<T> last(size_type len) const {
+    return Span<T>(*this).last(len);
+  }
+
+  constexpr Span<T> subspan(size_type pos = 0, size_type len = npos) const {
+    return Span<T>(*this).subspan(pos, len);
+  }
+
+  // Support for absl::Hash. Hashes like a `Span<T>` with the same elements.
+  template <typename H>
+  friend H AbslHashValue(H h, Span v) {
+    return H::combine_contiguous(std::move(h), v.data(), v.size());
+  }
+
+ private:
+  pointer ptr_;
+};
+
+// Class template argument deduction produces dynamic-extent spans, as it did
+// before `Span` had an extent parameter.
+template <typename T, size_t N>
+Span(T (&)[N]) -> Span<T>;
+
+template <typename T>
+Span(T* absl_nullability_unknown, size_t) -> Span<T>;
+
 // Span relationals
 
 // Equality is compared element-by-element, while ordering is lexicographical.
@@ -523,27 +808,27 @@
 // operator==
 template <typename T>
 constexpr bool operator==(Span<T> a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
+  return span_internal::EqualImpl<Span<const T>>(a, b);
 }
 template <typename T>
 constexpr bool operator==(Span<const T> a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
+  return span_internal::EqualImpl<Span<const T>>(a, b);
 }
 template <typename T>
 constexpr bool operator==(Span<T> a, Span<const T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
+  return span_internal::EqualImpl<Span<const T>>(a, b);
 }
 template <
     typename T, typename U,
     typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 constexpr bool operator==(const U& a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
+  return span_internal::EqualImpl<Span<const T>>(a, b);
 }
 template <
     typename T, typename U,
     typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 constexpr bool operator==(Span<T> a, const U& b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
+  return span_internal::EqualImpl<Span<const T>>(a, b);
 }
 
 // operator!=
@@ -575,27 +860,27 @@
 // operator<
 template <typename T>
 constexpr bool operator<(Span<T> a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
+  return span_internal::LessThanImpl<Span<const T>>(a, b);
 }
 template <typename T>
 constexpr bool operator<(Span<const T> a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
+  return span_internal::LessThanImpl<Span<const T>>(a, b);
 }
 template <typename T>
 constexpr bool operator<(Span<T> a, Span<const T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
+  return span_internal::LessThanImpl<Span<const T>>(a, b);
 }
 template <
     typename T, typename U,
     typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 constexpr bool operator<(const U& a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
+  return span_internal::LessThanImpl<Span<const T>>(a, b);
 }
 template <
     typename T, typename U,
     typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
 constexpr bool operator<(Span<T> a, const U& b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
+  return span_internal::LessThanImpl<Span<const T>>(a, b);
 }
 
 // operator>
diff --git a/absl/types/span_test.cc b/absl/types/span_test.cc
index 57cbb99..28b3758 100644
--- a/absl/types/span_test.cc
+++ b/absl/types/span_test.cc
@@ -908,4 +908,251 @@
             absl::HashOf(absl::FixedArray<int>{1, 2, 3}));
 }
 
+// Static extents.
+
+using S4 = absl::Span<int, 4>;
+using CS4 = absl::Span<const int, 4>;
+
+static_assert(
+    std::is_same_v<absl::Span<int>, absl::Span<int, absl::dynamic_extent>>);
+static_assert(absl::Span<int>::extent == absl::dynamic_extent);
+static_assert(S4::extent == 4);
+static_assert(sizeof(S4) == sizeof(int*), "only the pointer is stored");
+static_assert(!absl::type_traits_internal::IsOwner<S4>::value &&
+                  absl::type_traits_internal::IsView<S4>::value,
+              "Span is a view, not an owner");
+static_assert(std::is_trivially_destructible_v<S4> &&
+                  std::is_trivially_copyable_v<S4> &&
+                  std::is_trivially_copy_assignable_v<S4> &&
+                  std::is_trivially_copy_constructible_v<S4>,
+              "Span<T, N> should be trivial in everything except construction");
+static_assert(!std::is_default_constructible_v<S4>);
+static_assert(std::is_default_constructible_v<absl::Span<int, 0>>);
+
+// Conversions that keep the size are implicit.
+static_assert(std::is_convertible_v<int (&)[4], S4>);
+static_assert(std::is_convertible_v<std::array<int, 4>&, S4>);
+static_assert(std::is_convertible_v<const std::array<int, 4>&, CS4>);
+static_assert(std::is_convertible_v<S4, CS4>);
+static_assert(std::is_convertible_v<S4, absl::Span<int>>);
+static_assert(std::is_convertible_v<S4, absl::Span<const int>>);
+
+// Conversions that may change the size are explicit.
+static_assert(!std::is_convertible_v<absl::Span<int>, S4>);
+static_assert(std::is_constructible_v<S4, absl::Span<int>>);
+static_assert(!std::is_convertible_v<std::vector<int>&, S4>);
+static_assert(std::is_constructible_v<S4, std::vector<int>&>);
+static_assert(std::is_constructible_v<CS4, const std::vector<int>&>);
+static_assert(std::is_constructible_v<S4, int*, size_t>);
+
+// Size mismatches known at compile time are compile errors.
+static_assert(!std::is_constructible_v<S4, int (&)[3]>);
+static_assert(!std::is_constructible_v<S4, std::array<int, 3>&>);
+static_assert(!std::is_constructible_v<S4, absl::Span<int, 3>>);
+
+// Constness and derived-to-base conversions are rejected.
+static_assert(!std::is_constructible_v<S4, const std::array<int, 4>&>);
+static_assert(!std::is_constructible_v<S4, CS4>);
+static_assert(!std::is_constructible_v<S4, const std::vector<int>&>);
+static_assert(!std::is_constructible_v<S4, std::vector<int>&&>);
+// `Base` and `Derived` are defined above.
+static_assert(!std::is_constructible_v<absl::Span<Base, 2>, Derived (&)[2]>);
+static_assert(
+    !std::is_constructible_v<absl::Span<Base, 2>, absl::Span<Derived, 2>>);
+
+#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
+static_assert(std::ranges::borrowed_range<S4>);  // NOLINT(build/c++20)
+static_assert(std::ranges::view<S4>);            // NOLINT(build/c++20)
+#endif
+
+TEST(StaticSpan, DeductionGuidesKeepDynamicExtent) {
+  int a[4] = {};
+  const int ca[3] = {};
+  absl::Span s1(a);
+  absl::Span s2(ca);
+  absl::Span s3(a, 2);
+  static_assert(std::is_same_v<decltype(s1), absl::Span<int>>);
+  static_assert(std::is_same_v<decltype(s2), absl::Span<const int>>);
+  static_assert(std::is_same_v<decltype(s3), absl::Span<int>>);
+  EXPECT_EQ(s1.size(), 4);
+  EXPECT_EQ(s2.size(), 3);
+  EXPECT_EQ(s3.size(), 2);
+}
+
+TEST(StaticSpan, FromArray) {
+  int a[4] = {1, 2, 3, 4};
+  S4 s = a;
+  EXPECT_EQ(s.data(), a);
+  EXPECT_EQ(s.size(), 4);
+  EXPECT_FALSE(s.empty());
+  EXPECT_EQ(s.front(), 1);
+  EXPECT_EQ(s.back(), 4);
+  EXPECT_EQ(s[2], 3);
+  EXPECT_EQ(s.at(3), 4);
+  EXPECT_THAT(s, testing::ElementsAre(1, 2, 3, 4));
+  ABSL_BASE_INTERNAL_EXPECT_FAIL(s.at(4), std::out_of_range,
+                                 "failed bounds check");
+}
+
+TEST(StaticSpan, FromStdArray) {
+  std::array<int, 3> a = {1, 2, 3};
+  absl::Span<int, 3> s = a;
+  absl::Span<const int, 3> cs = a;
+  const std::array<int, 3>& ca = a;
+  absl::Span<const int, 3> ccs = ca;
+  EXPECT_EQ(s.data(), a.data());
+  EXPECT_EQ(cs.data(), a.data());
+  EXPECT_EQ(ccs.data(), a.data());
+}
+
+TEST(StaticSpan, ToDynamic) {
+  int a[4] = {1, 2, 3, 4};
+  S4 s = a;
+  absl::Span<int> d = s;
+  absl::Span<const int> cd = s;
+  absl::Span<int> direct(s);
+  EXPECT_EQ(d.data(), a);
+  EXPECT_EQ(d.size(), 4);
+  EXPECT_EQ(cd.data(), a);
+  EXPECT_EQ(cd.size(), 4);
+  EXPECT_EQ(direct.size(), 4);
+}
+
+TEST(StaticSpan, FromDynamicAndContainers) {
+  std::vector<int> v = {1, 2, 3, 4};
+  S4 from_span(absl::MakeSpan(v));
+  S4 from_vector(v);
+  CS4 from_const_vector(static_cast<const std::vector<int>&>(v));
+  S4 from_pointer(v.data(), v.size());
+  EXPECT_EQ(from_span.data(), v.data());
+  EXPECT_EQ(from_vector.data(), v.data());
+  EXPECT_EQ(from_const_vector.data(), v.data());
+  EXPECT_EQ(from_pointer.data(), v.data());
+
+  std::string str = "abc";
+  absl::Span<char, 3> chars(str);
+  EXPECT_EQ(chars.data(), str.data());
+}
+
+#if !defined(NDEBUG) || ABSL_OPTION_HARDENED
+TEST(StaticSpan, SizeMismatchDies) {
+  std::vector<int> v = {1, 2, 3};
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        S4 s(absl::MakeSpan(v));
+        (void)s;
+      },
+      "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        S4 s(v);
+        (void)s;
+      },
+      "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        S4 s(v.data(), v.size());
+        (void)s;
+      },
+      "");
+}
+
+TEST(StaticSpan, ElementAccessDies) {
+  int a[4] = {1, 2, 3, 4};
+  S4 s = a;
+  EXPECT_DEATH_IF_SUPPORTED(s[4], "");
+}
+#endif
+
+TEST(StaticSpan, StaticSubspans) {
+  int a[5] = {0, 1, 2, 3, 4};
+  absl::Span<int, 5> s = a;
+
+  auto first = s.first<2>();
+  auto last = s.last<2>();
+  auto middle = s.subspan<1, 3>();
+  auto rest = s.subspan<2>();
+  auto none = s.subspan<5>();
+  static_assert(std::is_same_v<decltype(first), absl::Span<int, 2>>);
+  static_assert(std::is_same_v<decltype(last), absl::Span<int, 2>>);
+  static_assert(std::is_same_v<decltype(middle), absl::Span<int, 3>>);
+  static_assert(std::is_same_v<decltype(rest), absl::Span<int, 3>>);
+  static_assert(std::is_same_v<decltype(none), absl::Span<int, 0>>);
+  EXPECT_THAT(first, testing::ElementsAre(0, 1));
+  EXPECT_THAT(last, testing::ElementsAre(3, 4));
+  EXPECT_THAT(middle, testing::ElementsAre(1, 2, 3));
+  EXPECT_THAT(rest, testing::ElementsAre(2, 3, 4));
+  EXPECT_TRUE(none.empty());
+}
+
+TEST(StaticSpan, DynamicSubspansOfStaticSpan) {
+  int a[5] = {0, 1, 2, 3, 4};
+  absl::Span<int, 5> s = a;
+
+  auto first = s.first(2);
+  static_assert(std::is_same_v<decltype(first), absl::Span<int>>);
+  EXPECT_THAT(first, testing::ElementsAre(0, 1));
+  EXPECT_THAT(s.last(1), testing::ElementsAre(4));
+  // Truncates like `Span<T>::subspan()`.
+  EXPECT_THAT(s.subspan(3, 10), testing::ElementsAre(3, 4));
+  ABSL_BASE_INTERNAL_EXPECT_FAIL(s.subspan(6), std::out_of_range,
+                                 "pos > size()");
+}
+
+TEST(StaticSpan, StaticSubspansOfDynamicSpan) {
+  std::vector<int> v = {0, 1, 2, 3, 4};
+  absl::Span<int> d = absl::MakeSpan(v);
+
+  auto first = d.first<2>();
+  auto last = d.last<3>();
+  auto middle = d.subspan<1, 2>();
+  auto rest = d.subspan<1>();
+  static_assert(std::is_same_v<decltype(first), absl::Span<int, 2>>);
+  static_assert(std::is_same_v<decltype(last), absl::Span<int, 3>>);
+  static_assert(std::is_same_v<decltype(middle), absl::Span<int, 2>>);
+  static_assert(std::is_same_v<decltype(rest), absl::Span<int>>);
+  EXPECT_THAT(first, testing::ElementsAre(0, 1));
+  EXPECT_THAT(last, testing::ElementsAre(2, 3, 4));
+  EXPECT_THAT(middle, testing::ElementsAre(1, 2));
+  EXPECT_THAT(rest, testing::ElementsAre(1, 2, 3, 4));
+
+  // Unlike `subspan(pos, len)`, the static versions never truncate.
+  ABSL_BASE_INTERNAL_EXPECT_FAIL(d.first<6>(), std::out_of_range,
+                                 "len > size()");
+  ABSL_BASE_INTERNAL_EXPECT_FAIL((d.subspan<4, 2>()), std::out_of_range,
+                                 "len > size()");
+  ABSL_BASE_INTERNAL_EXPECT_FAIL(d.subspan<6>(), std::out_of_range,
+                                 "pos > size()");
+}
+
+TEST(StaticSpan, Constexpr) {
+  static constexpr int kArray[3] = {1, 2, 3};
+  constexpr absl::Span<const int, 3> s = kArray;
+  constexpr absl::Span<const int> d = s;
+  static_assert(s.size() == 3);
+  static_assert(s[1] == 2);
+  static_assert(s.first<2>().back() == 2);
+  static_assert(s.subspan<1>().front() == 2);
+  static_assert(d.size() == 3);
+  static_assert(d.last<1>().front() == 3);
+}
+
+TEST(StaticSpan, IterationAndHash) {
+  int a[3] = {1, 2, 3};
+  absl::Span<const int, 3> s = a;
+  EXPECT_EQ(std::accumulate(s.begin(), s.end(), 0), 6);
+  EXPECT_THAT(std::vector<int>(s.rbegin(), s.rend()),
+              testing::ElementsAre(3, 2, 1));
+  EXPECT_EQ(absl::HashOf(s), absl::HashOf(absl::Span<const int>(a)));
+}
+
+TEST(StaticSpan, ComparesWithDynamicSpans) {
+  int a[3] = {1, 2, 3};
+  std::vector<int> v = {1, 2, 3};
+  absl::Span<const int, 3> s = a;
+  EXPECT_TRUE(s == absl::MakeConstSpan(v));
+  EXPECT_TRUE(absl::MakeConstSpan(v) == s);
+  EXPECT_FALSE(s < absl::MakeConstSpan(v));
+}
+
 }  // namespace