From 34b2b44a619da95e25ad05b0f4d83a75a6786ac7 Mon Sep 17 00:00:00 2001
From: Xuehai Pan <XuehaiPan@pku.edu.cn>
Date: Sat, 25 Jul 2026 17:56:01 +0800
Subject: [PATCH 1/6] fix(structseq): label unnamed fields in repr as
 <unnamed@N>

structseq_repr() labeled each visible slot by indexing tp_members by slot
position, but tp_members is packed with unnamed fields skipped, so every slot
at or after the first unnamed field borrowed the name of a later hidden field.
For os.stat_result the integer time slots printed as st_atime/st_mtime/st_ctime
(which are actually separate hidden float fields), so the repr disagreed with
both st[i] and the .st_atime attribute.

Walk the members alongside the visible slots and label unnamed slots
positionally as "<unnamed@N>", which is correct regardless of where the
unnamed fields sit among the visible ones.
---
 Lib/test/test_structseq.py                    | 34 +++++++++++++++++
 ...-07-25-14-06-33.gh-issue-154387.t2fIXs.rst |  6 +++
 Modules/_testcapimodule.c                     | 23 ++++++++++++
 Objects/structseq.c                           | 37 +++++++++++++------
 4 files changed, 88 insertions(+), 12 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst

diff --git a/Lib/test/test_structseq.py b/Lib/test/test_structseq.py
index 74506fc54de50e7..c2094b1c46df6f1 100644
--- a/Lib/test/test_structseq.py
+++ b/Lib/test/test_structseq.py
@@ -48,6 +48,40 @@ def test_repr(self):
         self.assertIn("st_ino=", rep)
         self.assertIn("st_dev=", rep)
 
+    def test_repr_with_unnamed_fields(self):
+        # gh-154387: unnamed fields must not borrow the name of a later hidden
+        # field in repr; they are shown as "<unnamed@N>" instead.
+        self.assertEqual(os.stat_result.n_sequence_fields, 10)
+        self.assertEqual(os.stat_result.n_unnamed_fields, 3)
+
+        r = os.stat_result(range(os.stat_result.n_sequence_fields))
+        rep = repr(r)
+        self.assertEqual(rep,
+            "os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, "
+            "st_uid=4, st_gid=5, st_size=6, <unnamed@7>=7, <unnamed@8>=8, "
+            "<unnamed@9>=9)")
+
+        # Regression guard: the hidden field names must not leak into the repr.
+        self.assertNotIn("st_atime=", rep)
+        self.assertNotIn("st_mtime=", rep)
+        self.assertNotIn("st_ctime=", rep)
+
+        # Supplying the hidden fields too must not change the repr.
+        r_full = os.stat_result(range(os.stat_result.n_fields))
+        self.assertEqual(repr(r_full), rep)
+        self.assertEqual(r_full[7], 7)
+        self.assertNotEqual(r_full[7], r_full.st_atime)
+
+    def test_repr_with_interspersed_unnamed_fields(self):
+        # gh-154387: unnamed fields need not be contiguous or trailing; each is
+        # shown at its own index rather than borrowing a neighbour's name.
+        _testcapi = import_helper.import_module("_testcapi")
+        cls = _testcapi.test_structseq_newtype_interspersed_unnamed()
+        self.assertEqual(cls.n_unnamed_fields, 2)
+        self.assertEqual(repr(cls(range(5))),
+            "_testcapi.Interspersed(first=0, <unnamed@1>=1, third=2, "
+            "<unnamed@3>=3, fifth=4)")
+
     def test_concat(self):
         t1 = time.gmtime()
         t2 = t1 + tuple(t1)
diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst
new file mode 100644
index 000000000000000..325fc101a62bc07
--- /dev/null
+++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst
@@ -0,0 +1,6 @@
+Fix the :func:`repr` of struct sequence objects that contain unnamed fields,
+such as :class:`os.stat_result`. Previously each unnamed field borrowed the
+name of a later, hidden field (for example the integer time slots of
+``os.stat_result`` were shown as ``st_atime``, ``st_mtime`` and ``st_ctime``,
+which are in fact separate hidden float fields); unnamed fields are now shown
+as ``<unnamed@N>``, where ``N`` is the sequence index. Patch by Xuehai Pan.
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index fb18a866e628128..c03d8c23306fb29 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -1304,6 +1304,27 @@ test_structseq_newtype_null_descr_doc(PyObject *Py_UNUSED(self),
     Py_RETURN_NONE;
 }
 
+static PyObject *
+test_structseq_newtype_interspersed_unnamed(PyObject *Py_UNUSED(self),
+                              PyObject *Py_UNUSED(args))
+{
+    // gh-154387: unnamed fields may appear anywhere among the visible fields,
+    // not only contiguous or trailing.
+    PyStructSequence_Field descr_fields[] = {
+        {"first", "field 0"},
+        {PyStructSequence_UnnamedField, "field 1"},
+        {"third", "field 2"},
+        {PyStructSequence_UnnamedField, "field 3"},
+        {"fifth", "field 4"},
+        {NULL, NULL},
+    };
+    PyStructSequence_Desc descr = {
+        "_testcapi.Interspersed", NULL, descr_fields, 5,
+    };
+
+    return (PyObject *)PyStructSequence_NewType(&descr);
+}
+
 typedef struct {
     PyThread_type_lock start_event;
     PyThread_type_lock exit_event;
@@ -3007,6 +3028,8 @@ static PyMethodDef TestMethods[] = {
         test_structseq_newtype_doesnt_leak, METH_NOARGS},
     {"test_structseq_newtype_null_descr_doc",
         test_structseq_newtype_null_descr_doc, METH_NOARGS},
+    {"test_structseq_newtype_interspersed_unnamed",
+        test_structseq_newtype_interspersed_unnamed, METH_NOARGS},
     {"pyobject_repr_from_null", pyobject_repr_from_null, METH_NOARGS},
     {"pyobject_str_from_null",  pyobject_str_from_null, METH_NOARGS},
     {"pyobject_bytes_from_null", pyobject_bytes_from_null, METH_NOARGS},
diff --git a/Objects/structseq.c b/Objects/structseq.c
index 9130fe6a133b1e4..221a1b267430e96 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -275,11 +275,11 @@ structseq_repr(PyObject *op)
 {
     PyStructSequence *obj = (PyStructSequence *)op;
     PyTypeObject *typ = Py_TYPE(obj);
+    Py_ssize_t n_visible_fields = VISIBLE_SIZE(obj);
 
     // count 5 characters per item: "x=1, "
     Py_ssize_t type_name_len = strlen(typ->tp_name);
-    Py_ssize_t prealloc = (type_name_len + 1
-                           + VISIBLE_SIZE(obj) * 5 + 1);
+    Py_ssize_t prealloc = type_name_len + 1 + n_visible_fields * 5 + 1;
     PyUnicodeWriter *writer = PyUnicodeWriter_Create(prealloc);
     if (writer == NULL) {
         return NULL;
@@ -293,7 +293,10 @@ structseq_repr(PyObject *op)
         goto error;
     }
 
-    for (Py_ssize_t i=0; i < VISIBLE_SIZE(obj); i++) {
+    // Unnamed slots have no tp_members entry; match each member to its slot by
+    // offset so unnamed slots print "<unnamed@i>", not a later name (gh-154387).
+    Py_ssize_t member_index = 0;
+    for (Py_ssize_t i = 0; i < n_visible_fields; i++) {
         if (i > 0) {
             // Write ", "
             if (PyUnicodeWriter_WriteChar(writer, ',') < 0) {
@@ -304,16 +307,26 @@ structseq_repr(PyObject *op)
             }
         }
 
-        // Write name
-        const char *name_utf8 = typ->tp_members[i].name;
-        if (name_utf8 == NULL) {
-            PyErr_Format(PyExc_SystemError,
-                         "In structseq_repr(), member %zd name is NULL"
-                         " for type %.500s", i, typ->tp_name);
-            goto error;
+        // The named member's slot is recovered from its offset.
+        const PyMemberDef *member = &typ->tp_members[member_index];
+        Py_ssize_t named_slot = -1;
+        if (member->name != NULL) {
+            // Recover the true slot index. See also function `initialize_members` below.
+            named_slot = (member->offset - (Py_ssize_t)offsetof(PyStructSequence, ob_item))
+                           / sizeof(PyObject *);
         }
-        if (PyUnicodeWriter_WriteUTF8(writer, name_utf8, -1) < 0) {
-            goto error;
+
+        // Write the field name, or "<unnamed@i>" for an unnamed field.
+        if (named_slot == i) {
+            if (PyUnicodeWriter_WriteUTF8(writer, member->name, -1) < 0) {
+                goto error;
+            }
+            member_index++;
+        }
+        else {
+            if (PyUnicodeWriter_Format(writer, "<unnamed@%zd>", i) < 0) {
+                goto error;
+            }
         }
 
         // Write "=" + repr(value)

From 23411b4fe0a6f7551819bf032013a1025e3c4fe0 Mon Sep 17 00:00:00 2001
From: Xuehai Pan <XuehaiPan@pku.edu.cn>
Date: Sat, 25 Jul 2026 18:25:43 +0800
Subject: [PATCH 2/6] fix: fix missing import due to git rebase

---
 Lib/test/test_structseq.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Lib/test/test_structseq.py b/Lib/test/test_structseq.py
index c2094b1c46df6f1..3636f4c588d2a5b 100644
--- a/Lib/test/test_structseq.py
+++ b/Lib/test/test_structseq.py
@@ -6,7 +6,7 @@
 import textwrap
 import time
 import unittest
-from test.support import script_helper
+from test.support import import_helper, script_helper
 
 
 class StructSeqTest(unittest.TestCase):

From 9b3f8fe293d09176f039a59756425f2624461957 Mon Sep 17 00:00:00 2001
From: Xuehai Pan <XuehaiPan@pku.edu.cn>
Date: Sat, 25 Jul 2026 19:58:21 +0800
Subject: [PATCH 3/6] test(structseq): cover a hidden named field in the
 interspersed test

Lower n_in_sequence to 4 in the _testcapi interspersed helper so the trailing
named field ("fifth") is hidden, and expand
test_repr_with_interspersed_unnamed_fields to assert the full surface: repr
(hidden field excluded), field counts, __match_args__, tuple()/len(), and
attribute access to visible and hidden fields (the latter both provided and
defaulted to None).
---
 Lib/test/test_structseq.py | 32 +++++++++++++++++++++++++++++---
 Modules/_testcapimodule.c  |  7 ++++---
 2 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/Lib/test/test_structseq.py b/Lib/test/test_structseq.py
index 3636f4c588d2a5b..86db91c7308a96f 100644
--- a/Lib/test/test_structseq.py
+++ b/Lib/test/test_structseq.py
@@ -74,13 +74,39 @@ def test_repr_with_unnamed_fields(self):
 
     def test_repr_with_interspersed_unnamed_fields(self):
         # gh-154387: unnamed fields need not be contiguous or trailing; each is
-        # shown at its own index rather than borrowing a neighbour's name.
+        # shown at its own index rather than borrowing a neighbour's name.  The
+        # trailing named field is hidden and must not appear in the repr.
         _testcapi = import_helper.import_module("_testcapi")
         cls = _testcapi.test_structseq_newtype_interspersed_unnamed()
+        self.assertEqual(cls.n_fields, 5)
+        self.assertEqual(cls.n_sequence_fields, 4)
         self.assertEqual(cls.n_unnamed_fields, 2)
-        self.assertEqual(repr(cls(range(5))),
+        self.assertEqual(cls.__match_args__, ("first", "third"))
+
+        t1 = cls(range(5))
+        self.assertEqual(repr(t1),
+            "_testcapi.Interspersed(first=0, <unnamed@1>=1, third=2, "
+            "<unnamed@3>=3)")
+        # Only the visible fields form the tuple; the hidden "fifth" is excluded.
+        self.assertEqual(tuple(t1), (0, 1, 2, 3))
+        self.assertEqual(len(t1), 4)
+        # Named fields are accessible by attribute, including the hidden one.
+        self.assertEqual(t1.first, 0)
+        self.assertEqual(t1.third, 2)
+        self.assertEqual(t1.fifth, 4)
+
+        t2 = cls(range(4))
+        self.assertEqual(repr(t2),
             "_testcapi.Interspersed(first=0, <unnamed@1>=1, third=2, "
-            "<unnamed@3>=3, fifth=4)")
+            "<unnamed@3>=3)")
+        # Only the visible fields form the tuple; the hidden "fifth" is excluded.
+        self.assertEqual(tuple(t2), (0, 1, 2, 3))
+        self.assertEqual(len(t2), 4)
+        # Named fields are accessible by attribute, including the hidden one.
+        # The hidden "fifth" is not set, so it returns None.
+        self.assertEqual(t2.first, 0)
+        self.assertEqual(t2.third, 2)
+        self.assertIsNone(t2.fifth)
 
     def test_concat(self):
         t1 = time.gmtime()
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index c03d8c23306fb29..43d8ff1f48538e6 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -1308,8 +1308,9 @@ static PyObject *
 test_structseq_newtype_interspersed_unnamed(PyObject *Py_UNUSED(self),
                               PyObject *Py_UNUSED(args))
 {
-    // gh-154387: unnamed fields may appear anywhere among the visible fields,
-    // not only contiguous or trailing.
+    // gh-154387: unnamed fields may appear anywhere among the visible fields
+    // (here at indices 1 and 3), and a named field may be hidden (here "fifth"
+    // at index 4, since n_in_sequence is 4).
     PyStructSequence_Field descr_fields[] = {
         {"first", "field 0"},
         {PyStructSequence_UnnamedField, "field 1"},
@@ -1319,7 +1320,7 @@ test_structseq_newtype_interspersed_unnamed(PyObject *Py_UNUSED(self),
         {NULL, NULL},
     };
     PyStructSequence_Desc descr = {
-        "_testcapi.Interspersed", NULL, descr_fields, 5,
+        "_testcapi.Interspersed", NULL, descr_fields, 4,
     };
 
     return (PyObject *)PyStructSequence_NewType(&descr);

From 227e08904d8741bb7b10a9e51b6d00c15ec0e6cd Mon Sep 17 00:00:00 2001
From: Xuehai Pan <XuehaiPan@pku.edu.cn>
Date: Sat, 25 Jul 2026 22:00:01 +0800
Subject: [PATCH 4/6] fix: remove `test_` prefix for functions in `_testcapi`

---
 Lib/test/test_structseq.py | 2 +-
 Modules/_testcapimodule.c  | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Lib/test/test_structseq.py b/Lib/test/test_structseq.py
index 86db91c7308a96f..487ad7b39c48f8b 100644
--- a/Lib/test/test_structseq.py
+++ b/Lib/test/test_structseq.py
@@ -77,7 +77,7 @@ def test_repr_with_interspersed_unnamed_fields(self):
         # shown at its own index rather than borrowing a neighbour's name.  The
         # trailing named field is hidden and must not appear in the repr.
         _testcapi = import_helper.import_module("_testcapi")
-        cls = _testcapi.test_structseq_newtype_interspersed_unnamed()
+        cls = _testcapi.structseq_newtype_interspersed_unnamed()
         self.assertEqual(cls.n_fields, 5)
         self.assertEqual(cls.n_sequence_fields, 4)
         self.assertEqual(cls.n_unnamed_fields, 2)
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index 43d8ff1f48538e6..ac57615cd7a78cd 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -1305,7 +1305,7 @@ test_structseq_newtype_null_descr_doc(PyObject *Py_UNUSED(self),
 }
 
 static PyObject *
-test_structseq_newtype_interspersed_unnamed(PyObject *Py_UNUSED(self),
+structseq_newtype_interspersed_unnamed(PyObject *Py_UNUSED(self),
                               PyObject *Py_UNUSED(args))
 {
     // gh-154387: unnamed fields may appear anywhere among the visible fields
@@ -3029,8 +3029,8 @@ static PyMethodDef TestMethods[] = {
         test_structseq_newtype_doesnt_leak, METH_NOARGS},
     {"test_structseq_newtype_null_descr_doc",
         test_structseq_newtype_null_descr_doc, METH_NOARGS},
-    {"test_structseq_newtype_interspersed_unnamed",
-        test_structseq_newtype_interspersed_unnamed, METH_NOARGS},
+    {"structseq_newtype_interspersed_unnamed",
+        structseq_newtype_interspersed_unnamed, METH_NOARGS},
     {"pyobject_repr_from_null", pyobject_repr_from_null, METH_NOARGS},
     {"pyobject_str_from_null",  pyobject_str_from_null, METH_NOARGS},
     {"pyobject_bytes_from_null", pyobject_bytes_from_null, METH_NOARGS},

From 50a2e22bde628a00b15f9a3e67412e78a2e476ef Mon Sep 17 00:00:00 2001
From: Xuehai Pan <XuehaiPan@pku.edu.cn>
Date: Sat, 25 Jul 2026 23:59:46 +0800
Subject: [PATCH 5/6] feat(os): custom repr for os.stat_result showing time
 fields by name

os.stat_result has three unnamed integer time slots (7-9) whose values are
mirrored by the named float fields st_atime/st_mtime/st_ctime (statresult_new
fills the latter from the former). The generic struct sequence repr shows
those unnamed slots as <unnamed@7..9>, which is uninformative.

Add statresult_repr showing the named fields (st_mode..st_size and the float
st_atime/st_mtime/st_ctime) by name, matching the attributes. Install it
through the type dict via PyObject_SetAttrString so repr() and st.__repr__()
resolve to the same function; a raw tp_repr assignment would leave the
__repr__ wrapper readied by PyStructSequence_NewType pointing at the generic
repr. Other struct sequences keep the generic <unnamed@N>.
---
 Lib/test/test_structseq.py                    | 93 +++++++++++++------
 ...-07-25-14-06-33.gh-issue-154387.t2fIXs.rst | 10 +-
 Modules/posixmodule.c                         | 73 +++++++++++++++
 3 files changed, 144 insertions(+), 32 deletions(-)

diff --git a/Lib/test/test_structseq.py b/Lib/test/test_structseq.py
index 487ad7b39c48f8b..96aa3b337369bc5 100644
--- a/Lib/test/test_structseq.py
+++ b/Lib/test/test_structseq.py
@@ -49,33 +49,9 @@ def test_repr(self):
         self.assertIn("st_dev=", rep)
 
     def test_repr_with_unnamed_fields(self):
-        # gh-154387: unnamed fields must not borrow the name of a later hidden
-        # field in repr; they are shown as "<unnamed@N>" instead.
-        self.assertEqual(os.stat_result.n_sequence_fields, 10)
-        self.assertEqual(os.stat_result.n_unnamed_fields, 3)
-
-        r = os.stat_result(range(os.stat_result.n_sequence_fields))
-        rep = repr(r)
-        self.assertEqual(rep,
-            "os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, "
-            "st_uid=4, st_gid=5, st_size=6, <unnamed@7>=7, <unnamed@8>=8, "
-            "<unnamed@9>=9)")
-
-        # Regression guard: the hidden field names must not leak into the repr.
-        self.assertNotIn("st_atime=", rep)
-        self.assertNotIn("st_mtime=", rep)
-        self.assertNotIn("st_ctime=", rep)
-
-        # Supplying the hidden fields too must not change the repr.
-        r_full = os.stat_result(range(os.stat_result.n_fields))
-        self.assertEqual(repr(r_full), rep)
-        self.assertEqual(r_full[7], 7)
-        self.assertNotEqual(r_full[7], r_full.st_atime)
-
-    def test_repr_with_interspersed_unnamed_fields(self):
-        # gh-154387: unnamed fields need not be contiguous or trailing; each is
-        # shown at its own index rather than borrowing a neighbour's name.  The
-        # trailing named field is hidden and must not appear in the repr.
+        # gh-154387: each unnamed field is shown at its own index rather than
+        # borrowing a neighbour's name. Unnamed fields need not be contiguous or
+        # trailing.
         _testcapi = import_helper.import_module("_testcapi")
         cls = _testcapi.structseq_newtype_interspersed_unnamed()
         self.assertEqual(cls.n_fields, 5)
@@ -108,6 +84,69 @@ def test_repr_with_interspersed_unnamed_fields(self):
         self.assertEqual(t2.third, 2)
         self.assertIsNone(t2.fifth)
 
+    def test_os_stat_result_has_custom_repr(self):
+        # gh-154387: os.stat_result has a custom repr (statresult_repr) showing
+        # the float times st_atime/st_mtime/st_ctime by name, not the unnamed
+        # integer slots with generic "<unnamed@N>".
+        self.assertEqual(os.stat_result.n_sequence_fields, 10)
+        self.assertEqual(os.stat_result.n_unnamed_fields, 3)
+
+        # All fields supplied: st_atime/st_mtime/st_ctime are the float slots.
+        r1 = os.stat_result(range(os.stat_result.n_fields))
+        rep = repr(r1)
+        self.assertEqual(rep,
+            "os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, "
+            "st_uid=4, st_gid=5, st_size=6, st_atime=10, st_mtime=11, "
+            "st_ctime=12)")
+        self.assertNotIn("<unnamed@", rep)
+        self.assertEqual(r1.st_atime, 10)
+        self.assertEqual(r1.st_mtime, 11)
+        self.assertEqual(r1.st_ctime, 12)
+
+        # Only the visible slots supplied: statresult_new fills the float times
+        # from the integer slots, so the repr shows those filled values.
+        r2 = os.stat_result(range(10))
+        self.assertEqual(repr(r2),
+            "os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, "
+            "st_uid=4, st_gid=5, st_size=6, st_atime=7, st_mtime=8, "
+            "st_ctime=9)")
+        self.assertEqual(r2.st_atime, 7)
+        self.assertEqual(r2.st_mtime, 8)
+        self.assertEqual(r2.st_ctime, 9)
+
+        # The st_atime/st_mtime slots are supplied, but st_ctime is not; the
+        # st_ctime float slot is filled from the st_ctime integer slot.
+        r3 = os.stat_result(range(12))
+        self.assertEqual(repr(r3),
+            "os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, "
+            "st_uid=4, st_gid=5, st_size=6, st_atime=10, st_mtime=11, "
+            "st_ctime=9)")
+        self.assertEqual(r3.st_atime, 10)
+        self.assertEqual(r3.st_mtime, 11)
+        self.assertEqual(r3.st_ctime, 9)
+
+        # The st_mtime slot is supplied, but st_atime/st_ctime are not; the
+        # st_atime/st_ctime float slots are filled from the st_atime/st_ctime
+        # integer slots.
+        r4 = os.stat_result(range(10), {'st_mtime': -1.0})
+        self.assertEqual(repr(r4),
+            "os.stat_result(st_mode=0, st_ino=1, st_dev=2, st_nlink=3, "
+            "st_uid=4, st_gid=5, st_size=6, st_atime=7, st_mtime=-1.0, "
+            "st_ctime=9)")
+        self.assertEqual(r4.st_atime, 7)
+        self.assertEqual(r4.st_mtime, -1.0)
+        self.assertEqual(r4.st_ctime, 9)
+
+        # repr(), __repr__(), and str() must all resolve to the custom repr
+        # (a raw tp_repr override left __repr__() diverging).
+        for r in (r1, r2, r3, r4):
+            rep = repr(r)
+            self.assertEqual(r.__repr__(), rep)
+            self.assertEqual(type(r).__repr__(r), rep)
+            self.assertEqual(str(r), rep)
+            self.assertEqual(f"{r!r}", rep)
+            self.assertEqual(f"{r!s}", rep)
+
     def test_concat(self):
         t1 = time.gmtime()
         t2 = t1 + tuple(t1)
diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst
index 325fc101a62bc07..177a3ff4c61eb49 100644
--- a/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst
+++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-07-25-14-06-33.gh-issue-154387.t2fIXs.rst
@@ -1,6 +1,6 @@
 Fix the :func:`repr` of struct sequence objects that contain unnamed fields,
-such as :class:`os.stat_result`. Previously each unnamed field borrowed the
-name of a later, hidden field (for example the integer time slots of
-``os.stat_result`` were shown as ``st_atime``, ``st_mtime`` and ``st_ctime``,
-which are in fact separate hidden float fields); unnamed fields are now shown
-as ``<unnamed@N>``, where ``N`` is the sequence index. Patch by Xuehai Pan.
+such as :class:`os.stat_result`, whose integer time slots previously borrowed
+the ``st_atime``/``st_mtime``/``st_ctime`` names of separate hidden float
+fields. Unnamed fields are now shown as ``<unnamed@N>`` (``N`` is the sequence
+index); :class:`os.stat_result` uses a dedicated repr that shows the float
+``st_atime``, ``st_mtime`` and ``st_ctime`` fields by name. Patch by Xuehai Pan.
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 350f56c393d3b97..d3f77554dc6e948 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -2572,6 +2572,8 @@ statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     /* If we have been initialized from a tuple,
        st_?time might be set to None. Initialize it
        from the int slots.  */
+    /* See also statresult_repr() below, which assumes that the float slots are
+       always initialized. */
     for (i = 7; i <= 9; i++) {
         if (result->ob_item[i+3] == Py_None) {
             Py_DECREF(Py_None);
@@ -2581,6 +2583,63 @@ statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     return (PyObject*)result;
 }
 
+static PyObject *
+statresult_repr(PyObject *op, PyObject *Py_UNUSED(ignored))
+{
+    // gh-154387: Show the unnamed integer slots 7-9 with following named float
+    // slots st_atime/st_mtime/st_ctime instead of the generic "<unnamed@N>".
+    // The custom statresult_new() above always initializes the float slots.
+    // So it is safe to use the float slots for the repr().
+    PyTypeObject *type = Py_TYPE(op);
+    PyUnicodeWriter *writer = PyUnicodeWriter_Create(128);
+    if (writer == NULL) {
+        return NULL;
+    }
+    if (PyUnicodeWriter_WriteUTF8(writer, type->tp_name, -1) < 0) {
+        goto error;
+    }
+    if (PyUnicodeWriter_WriteChar(writer, '(') < 0) {
+        goto error;
+    }
+    // The first 10 packed members: st_mode..st_size and the 3 float times
+    // st_atime/st_mtime/st_ctime (tp_members omits the unnamed slots 7-9).
+    // NB: This approach assumes the 3 unnamed slots are at the end of the
+    // visible members, which is true for the current stat_result_desc.
+    for (Py_ssize_t i = 0; i < 10; i++) {
+        if (i > 0 && PyUnicodeWriter_WriteUTF8(writer, ", ", 2) < 0) {
+            goto error;
+        }
+        PyMemberDef *member = &type->tp_members[i];
+        if (PyUnicodeWriter_WriteUTF8(writer, member->name, -1) < 0) {
+            goto error;
+        }
+        if (PyUnicodeWriter_WriteChar(writer, '=') < 0) {
+            goto error;
+        }
+        PyObject *value = PyMember_GetOne((const char *)op, member);
+        if (value == NULL) {
+            goto error;
+        }
+        if (PyUnicodeWriter_WriteRepr(writer, value) < 0) {
+            Py_DECREF(value);
+            goto error;
+        }
+        Py_DECREF(value);
+    }
+    if (PyUnicodeWriter_WriteChar(writer, ')') < 0) {
+        goto error;
+    }
+    return PyUnicodeWriter_Finish(writer);
+
+error:
+    PyUnicodeWriter_Discard(writer);
+    return NULL;
+}
+
+static PyMethodDef statresult_repr_methoddef = {
+    "__repr__", statresult_repr, METH_NOARGS, NULL,
+};
+
 static int
 _posix_clear(PyObject *module)
 {
@@ -18860,6 +18919,20 @@ posixmodule_exec(PyObject *m)
     }
     state->statresult_new_orig = ((PyTypeObject *)state->StatResultType)->tp_new;
     ((PyTypeObject *)state->StatResultType)->tp_new = statresult_new;
+    // Install __repr__ through the type dict so repr() and st.__repr__()
+    // resolve to the same function; a raw type->tp_repr assignment leaves the
+    // stale __repr__ wrapper which is readied by PyStructSequence_NewType.
+    PyObject *statresult_repr_descr = PyDescr_NewMethod(
+        (PyTypeObject *)state->StatResultType, &statresult_repr_methoddef);
+    if (statresult_repr_descr == NULL) {
+        return -1;
+    }
+    if (PyObject_SetAttrString(state->StatResultType, "__repr__",
+                               statresult_repr_descr) < 0) {
+        Py_DECREF(statresult_repr_descr);
+        return -1;
+    }
+    Py_DECREF(statresult_repr_descr);
 
     state->StatVFSResultType = (PyObject *)PyStructSequence_NewType(&statvfs_result_desc);
     if (PyModule_AddObjectRef(m, "statvfs_result", state->StatVFSResultType) < 0) {

From 9fde8ce629373ebd58038015c500eb5f5a90a004 Mon Sep 17 00:00:00 2001
From: Xuehai Pan <XuehaiPan@pku.edu.cn>
Date: Mon, 27 Jul 2026 01:10:15 +0800
Subject: [PATCH 6/6] ci: try fix ci

---
 Lib/test/test_class.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index 62d8806b75d9db0..08778eb9355c5f3 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -1019,6 +1019,8 @@ def test_detach_materialized_dict_no_memory(self):
             import test.support
             import _testcapi
 
+            set_nomemory = _testcapi.set_nomemory  # eagerly load the function
+
             class A:
                 def __init__(self):
                     self.a = 1
@@ -1026,7 +1028,7 @@ def __init__(self):
             a = A()
             d = a.__dict__
             with test.support.catch_unraisable_exception() as ex:
-                _testcapi.set_nomemory(0, 1)
+                set_nomemory(0, 1)
                 del a
                 assert ex.unraisable.exc_type is MemoryError
             try: