gh-94937: Allow len() to return large Python lengths

Author: cjc0013

Doc/library/functions.rst

@@ -1158,8 +1158,9 @@ are always available.  They are listed here in alphabetical order.
 
    .. impl-detail::
 
-      ``len`` raises :exc:`OverflowError` on lengths larger than
-      :data:`sys.maxsize`, such as :class:`range(2 ** 100) <range>`.
+      CPython's C length protocol is limited to :data:`sys.maxsize`.
+      When that limit is reached, ``len`` may still return a larger Python
+      integer if the object's :meth:`~object.__len__` method can provide one.
 
 
 .. _func-list:

Doc/library/stdtypes.rst

@@ -1533,8 +1533,9 @@ loops.
    indices.
 
    Ranges containing absolute values larger than :data:`sys.maxsize` are
-   permitted but some features (such as :func:`len`) may raise
-   :exc:`OverflowError`.
+   permitted, though some operations that use the C length protocol may still
+   raise :exc:`OverflowError` for ranges with lengths larger than
+   :data:`!sys.maxsize`.
 
    Range examples::
 

Doc/reference/datamodel.rst

@@ -3226,11 +3226,10 @@ through the object's keys; for sequences, it should iterate through the values.
 
    .. impl-detail::
 
-      In CPython, the length is required to be at most :data:`sys.maxsize`.
-      If the length is larger than :data:`!sys.maxsize` some features (such as
-      :func:`len`) may raise :exc:`OverflowError`.  To prevent raising
-      :exc:`!OverflowError` by truth value testing, an object must define a
-      :meth:`~object.__bool__` method.
+      In CPython, the C length protocol is limited to :data:`sys.maxsize`.
+      Some features that use that protocol may raise :exc:`OverflowError`
+      for larger lengths.  To prevent raising :exc:`!OverflowError` by truth
+      value testing, an object must define a :meth:`~object.__bool__` method.
 
 
 .. method:: object.__length_hint__(self)

Include/internal/pycore_abstract.h

@@ -21,6 +21,7 @@ PyAPI_FUNC(PyObject *) _PyNumber_PowerNoMod(PyObject *lhs, PyObject *rhs);
 PyAPI_FUNC(PyObject *) _PyNumber_InPlacePowerNoMod(PyObject *lhs, PyObject *rhs);
 
 PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o);
+PyAPI_FUNC(PyObject *) _PyObject_LengthAsPyLong(PyObject *o);
 
 /* === Sequence protocol ================================================ */
 

Lib/test/test_builtin.py

@@ -1364,7 +1364,10 @@ def __len__(self):
         class HugeLen:
             def __len__(self):
                 return sys.maxsize + 1
-        self.assertRaises(OverflowError, len, HugeLen())
+        self.assertEqual(len(HugeLen()), sys.maxsize + 1)
+        huge_len = HugeLen()
+        huge_len.__len__ = lambda: 0
+        self.assertEqual(len(huge_len), sys.maxsize + 1)
         class HugeNegativeLen:
             def __len__(self):
                 return -sys.maxsize-10

Lib/test/test_random.py

@@ -5,6 +5,7 @@
 import time
 import pickle
 import shlex
+import sys
 import warnings
 import test.support
 
@@ -122,6 +123,7 @@ def test_choice(self):
             choice([])
         self.assertEqual(choice([50]), 50)
         self.assertIn(choice([25, 75]), [25, 75])
+        self.assertIn(choice(range(sys.maxsize * 2)), range(sys.maxsize * 2))
 
     def test_choice_with_numpy(self):
         # Accommodation for NumPy arrays which have disabled __bool__().
@@ -177,6 +179,11 @@ def test_sample_inputs(self):
         self.gen.sample(range(20), 2)
         self.gen.sample(str('abcdefghijklmnopqrst'), 2)
         self.gen.sample(tuple('abcdefghijklmnopqrst'), 2)
+        population = range(sys.maxsize * 2)
+        sample = self.gen.sample(population, 10)
+        self.assertEqual(len(sample), 10)
+        self.assertEqual(len(set(sample)), 10)
+        self.assertTrue(all(element in population for element in sample))
 
     def test_sample_on_dicts(self):
         self.assertRaises(TypeError, self.gen.sample, dict.fromkeys('abcdef'), 2)

Lib/test/test_range.py

@@ -162,24 +162,14 @@ def test_large_operands(self):
 
     def test_large_range(self):
         # Check long ranges (len > sys.maxsize)
-        # len() is expected to fail due to limitations of the __len__ protocol
-        def _range_len(x):
-            try:
-                length = len(x)
-            except OverflowError:
-                step = x[1] - x[0]
-                length = 1 + ((x[-1] - x[0]) // step)
-            return length
-
         a = -sys.maxsize
         b = sys.maxsize
         expected_len = b - a
         x = range(a, b)
         self.assertIn(a, x)
         self.assertNotIn(b, x)
-        self.assertRaises(OverflowError, len, x)
+        self.assertEqual(len(x), expected_len)
         self.assertTrue(x)
-        self.assertEqual(_range_len(x), expected_len)
         self.assertEqual(x[0], a)
         idx = sys.maxsize+1
         self.assertEqual(x[idx], a+idx)
@@ -195,9 +185,8 @@ def _range_len(x):
         x = range(a, b)
         self.assertIn(a, x)
         self.assertNotIn(b, x)
-        self.assertRaises(OverflowError, len, x)
+        self.assertEqual(len(x), expected_len)
         self.assertTrue(x)
-        self.assertEqual(_range_len(x), expected_len)
         self.assertEqual(x[0], a)
         idx = sys.maxsize+1
         self.assertEqual(x[idx], a+idx)
@@ -214,9 +203,8 @@ def _range_len(x):
         x = range(a, b, c)
         self.assertIn(a, x)
         self.assertNotIn(b, x)
-        self.assertRaises(OverflowError, len, x)
+        self.assertEqual(len(x), expected_len)
         self.assertTrue(x)
-        self.assertEqual(_range_len(x), expected_len)
         self.assertEqual(x[0], a)
         idx = sys.maxsize+1
         self.assertEqual(x[idx], a+(idx*c))
@@ -233,9 +221,8 @@ def _range_len(x):
         x = range(a, b, c)
         self.assertIn(a, x)
         self.assertNotIn(b, x)
-        self.assertRaises(OverflowError, len, x)
+        self.assertEqual(len(x), expected_len)
         self.assertTrue(x)
-        self.assertEqual(_range_len(x), expected_len)
         self.assertEqual(x[0], a)
         idx = sys.maxsize+1
         self.assertEqual(x[idx], a+(idx*c))

Misc/NEWS.d/next/Core_and_Builtins/2026-05-29-12-25-00.gh-issue-94937.len-overflow-fallback.rst

@@ -0,0 +1,3 @@
+Allow :func:`len` to return values larger than :data:`sys.maxsize` when
+``__len__`` can provide a Python integer fallback, including for large
+:class:`range` objects.

Objects/abstract.c

@@ -79,6 +79,48 @@ PyObject_Length(PyObject *o)
 }
 #define PyObject_Length PyObject_Size
 
+PyObject *
+_PyObject_LengthAsPyLong(PyObject *o)
+{
+    Py_ssize_t res = PyObject_Size(o);
+    if (res >= 0) {
+        return PyLong_FromSsize_t(res);
+    }
+    assert(PyErr_Occurred());
+    if (!PyErr_ExceptionMatches(PyExc_OverflowError)) {
+        return NULL;
+    }
+
+    PyErr_Clear();
+    PyObject *meth = _PyObject_LookupSpecial(o, &_Py_ID(__len__));
+    if (meth == NULL) {
+        if (!PyErr_Occurred()) {
+            type_error("object of type '%.200s' has no len()", o);
+        }
+        return NULL;
+    }
+
+    PyObject *len = _PyObject_CallNoArgs(meth);
+    Py_DECREF(meth);
+    if (len == NULL) {
+        return NULL;
+    }
+
+    Py_SETREF(len, PyNumber_Index(len));
+    if (len == NULL) {
+        return NULL;
+    }
+
+    assert(PyLong_Check(len));
+    if (_PyLong_IsNegative((PyLongObject *)len)) {
+        Py_DECREF(len);
+        PyErr_SetString(PyExc_ValueError,
+                        "__len__() should return >= 0");
+        return NULL;
+    }
+    return len;
+}
+
 int
 _PyObject_HasLen(PyObject *o) {
     return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||

Objects/rangeobject.c

@@ -329,6 +329,13 @@ range_length(PyObject *op)
     return PyLong_AsSsize_t(r->length);
 }
 
+static PyObject *
+range_len(PyObject *op, PyObject *Py_UNUSED(ignored))
+{
+    rangeobject *r = (rangeobject*)op;
+    return Py_NewRef(r->length);
+}
+
 static PyObject *
 compute_item(rangeobject *r, PyObject *i)
 {
@@ -779,6 +786,7 @@ PyDoc_STRVAR(index_doc,
 "Raise ValueError if the value is not present.");
 
 static PyMethodDef range_methods[] = {
+    {"__len__",         range_len,                  METH_NOARGS | METH_COEXIST, NULL},
     {"__reversed__",    range_reverse,              METH_NOARGS, reverse_doc},
     {"__reduce__",      range_reduce,               METH_NOARGS},
     {"count",           range_count,                METH_O,      count_doc},