python
diff --git a/‎Include/internal/pycore_code.h‎
Lines changed: 2 additions & 2 deletions b/‎Include/internal/pycore_code.h‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎Lib/test/test_opcache.py‎
Lines changed: 27 additions & 0 deletions b/‎Lib/test/test_opcache.py‎
Lines changed: 27 additions & 0 deletions
diff --git a/‎Misc/NEWS.d/next/Core_and_Builtins/2025-11-11-13-40-45.gh-issue-141367.I5KY7F.rst‎
Lines changed: 2 additions & 0 deletions b/‎Misc/NEWS.d/next/Core_and_Builtins/2025-11-11-13-40-45.gh-issue-141367.I5KY7F.rst‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎Python/bytecodes.c‎
Lines changed: 1 addition & 2 deletions b/‎Python/bytecodes.c‎
Lines changed: 1 addition & 2 deletions
diff --git a/‎Python/executor_cases.c.h‎
Lines changed: 0 additions & 4 deletions b/‎Python/executor_cases.c.h‎
Lines changed: 0 additions & 4 deletions
diff --git a/‎Python/generated_cases.c.h‎
Lines changed: 1 addition & 6 deletions b/‎Python/generated_cases.c.h‎
Lines changed: 1 addition & 6 deletions
diff --git a/‎Python/specialize.c‎
Lines changed: 11 additions & 6 deletions b/‎Python/specialize.c‎
Lines changed: 11 additions & 6 deletions
@@ -311,8 +311,8 @@ PyAPI_FUNC(void) _Py_Specialize_LoadGlobal(PyObject *globals, PyObject *builtins
                                       _Py_CODEUNIT *instr, PyObject *name);
 PyAPI_FUNC(void) _Py_Specialize_StoreSubscr(_PyStackRef container, _PyStackRef sub,
                                        _Py_CODEUNIT *instr);
-PyAPI_FUNC(void) _Py_Specialize_Call(_PyStackRef callable, _Py_CODEUNIT *instr,
-                                int nargs);
+PyAPI_FUNC(void) _Py_Specialize_Call(_PyStackRef callable, _PyStackRef self_or_null,
+                                _Py_CODEUNIT *instr, int nargs);
 PyAPI_FUNC(void) _Py_Specialize_CallKw(_PyStackRef callable, _Py_CODEUNIT *instr,
                                   int nargs);
 PyAPI_FUNC(void) _Py_Specialize_BinaryOp(_PyStackRef lhs, _PyStackRef rhs, _Py_CODEUNIT *instr,
 
@@ -1872,6 +1872,33 @@ def for_iter_generator():
         self.assert_specialized(for_iter_generator, "FOR_ITER_GEN")
         self.assert_no_opcode(for_iter_generator, "FOR_ITER")
 
+    @cpython_only
+    @requires_specialization_ft
+    def test_call_list_append(self):
+        # gh-141367: only exact lists should use
+        # CALL_LIST_APPEND instruction after specialization.
+
+        r = range(_testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        def list_append(l):
+            for _ in r:
+                l.append(1)
+
+        list_append([])
+        self.assert_specialized(list_append, "CALL_LIST_APPEND")
+        self.assert_no_opcode(list_append, "CALL_METHOD_DESCRIPTOR_O")
+        self.assert_no_opcode(list_append, "CALL")
+
+        def my_list_append(l):
+            for _ in r:
+                l.append(1)
+
+        class MyList(list): pass
+        my_list_append(MyList())
+        self.assert_specialized(my_list_append, "CALL_METHOD_DESCRIPTOR_O")
+        self.assert_no_opcode(my_list_append, "CALL_LIST_APPEND")
+        self.assert_no_opcode(my_list_append, "CALL")
+
 
 if __name__ == "__main__":
     unittest.main()
@@ -0,0 +1,2 @@
+Specialize ``CALL_LIST_APPEND`` instruction only for lists, not for list
+subclasses, to avoid unnecessary deopt. Patch by Mikhail Efimov.
@@ -3689,7 +3689,7 @@ dummy_func(
             #if ENABLE_SPECIALIZATION_FT
             if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
                 next_instr = this_instr;
-                _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
+                _Py_Specialize_Call(callable, self_or_null, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
                 DISPATCH_SAME_OPARG();
             }
             OPCODE_DEFERRED_INC(CALL);
@@ -4395,7 +4395,6 @@ dummy_func(
             assert(oparg == 1);
             PyObject *self_o = PyStackRef_AsPyObjectBorrow(self);
 
-            DEOPT_IF(!PyList_CheckExact(self_o));
             DEOPT_IF(!LOCK_OBJECT(self_o));
             STAT_INC(CALL, hit);
             int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg));
 
@@ -1602,8 +1602,8 @@ specialize_class_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs)
 }
 
 static int
-specialize_method_descriptor(PyMethodDescrObject *descr, _Py_CODEUNIT *instr,
-                             int nargs)
+specialize_method_descriptor(PyMethodDescrObject *descr, PyObject *self_or_null,
+                             _Py_CODEUNIT *instr, int nargs)
 {
     switch (descr->d_method->ml_flags &
         (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O |
@@ -1627,8 +1627,11 @@ specialize_method_descriptor(PyMethodDescrObject *descr, _Py_CODEUNIT *instr,
             bool pop = (next.op.code == POP_TOP);
             int oparg = instr->op.arg;
             if ((PyObject *)descr == list_append && oparg == 1 && pop) {
-                specialize(instr, CALL_LIST_APPEND);
-                return 0;
+                assert(self_or_null != NULL);
+                if (PyList_CheckExact(self_or_null)) {
+                    specialize(instr, CALL_LIST_APPEND);
+                    return 0;
+                }
             }
             specialize(instr, CALL_METHOD_DESCRIPTOR_O);
             return 0;
@@ -1766,7 +1769,7 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs)
 }
 
 Py_NO_INLINE void
-_Py_Specialize_Call(_PyStackRef callable_st, _Py_CODEUNIT *instr, int nargs)
+_Py_Specialize_Call(_PyStackRef callable_st, _PyStackRef self_or_null_st, _Py_CODEUNIT *instr, int nargs)
 {
     PyObject *callable = PyStackRef_AsPyObjectBorrow(callable_st);
 
@@ -1784,7 +1787,9 @@ _Py_Specialize_Call(_PyStackRef callable_st, _Py_CODEUNIT *instr, int nargs)
         fail = specialize_class_call(callable, instr, nargs);
     }
     else if (Py_IS_TYPE(callable, &PyMethodDescr_Type)) {
-        fail = specialize_method_descriptor((PyMethodDescrObject *)callable, instr, nargs);
+        PyObject *self_or_null = PyStackRef_AsPyObjectBorrow(self_or_null_st);
+        fail = specialize_method_descriptor((PyMethodDescrObject *)callable,
+                                            self_or_null, instr, nargs);
     }
     else if (PyMethod_Check(callable)) {
         PyObject *func = ((PyMethodObject *)callable)->im_func;
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	+Specialize ``CALL_LIST_APPEND`` instruction only for lists, not for list
	`2`	`+subclasses, to avoid unnecessary deopt. Patch by Mikhail Efimov.`
Original file line number	Diff line number	Diff line change
`@@ -1602,8 +1602,8 @@ specialize_class_call(PyObject callable, _Py_CODEUNIT instr, int nargs)`
`1602`	`1602`	`}`
`1603`	`1603`
`1604`	`1604`	`static int`
`1605`		`-specialize_method_descriptor(PyMethodDescrObject descr, _Py_CODEUNIT instr,`
`1606`		`- int nargs)`
	`1605`	`+specialize_method_descriptor(PyMethodDescrObject descr, PyObject self_or_null,`
	`1606`	`+ _Py_CODEUNIT *instr, int nargs)`
`1607`	`1607`	`{`
`1608`	`1608`	`switch (descr->d_method->ml_flags &`
`1609`	`1609`	`(METH_VARARGS \| METH_FASTCALL \| METH_NOARGS \| METH_O \|`
`@@ -1627,8 +1627,11 @@ specialize_method_descriptor(PyMethodDescrObject descr, _Py_CODEUNIT instr,`
`1627`	`1627`	`bool pop = (next.op.code == POP_TOP);`
`1628`	`1628`	`int oparg = instr->op.arg;`
`1629`	`1629`	`if ((PyObject *)descr == list_append && oparg == 1 && pop) {`
`1630`		`- specialize(instr, CALL_LIST_APPEND);`
`1631`		`- return 0;`
	`1630`	`+ assert(self_or_null != NULL);`
	`1631`	`+ if (PyList_CheckExact(self_or_null)) {`
	`1632`	`+ specialize(instr, CALL_LIST_APPEND);`
	`1633`	`+ return 0;`
	`1634`	`+ }`
`1632`	`1635`	`}`
`1633`	`1636`	`specialize(instr, CALL_METHOD_DESCRIPTOR_O);`
`1634`	`1637`	`return 0;`
`@@ -1766,7 +1769,7 @@ specialize_c_call(PyObject callable, _Py_CODEUNIT instr, int nargs)`
`1766`	`1769`	`}`
`1767`	`1770`
`1768`	`1771`	`Py_NO_INLINE void`
`1769`		`-_Py_Specialize_Call(_PyStackRef callable_st, _Py_CODEUNIT *instr, int nargs)`
	`1772`	`+_Py_Specialize_Call(_PyStackRef callable_st, _PyStackRef self_or_null_st, _Py_CODEUNIT *instr, int nargs)`
`1770`	`1773`	`{`
`1771`	`1774`	`PyObject *callable = PyStackRef_AsPyObjectBorrow(callable_st);`
`1772`	`1775`
`@@ -1784,7 +1787,9 @@ _Py_Specialize_Call(_PyStackRef callable_st, _Py_CODEUNIT *instr, int nargs)`
`1784`	`1787`	`fail = specialize_class_call(callable, instr, nargs);`
`1785`	`1788`	`}`
`1786`	`1789`	`else if (Py_IS_TYPE(callable, &PyMethodDescr_Type)) {`
`1787`		`- fail = specialize_method_descriptor((PyMethodDescrObject *)callable, instr, nargs);`
	`1790`	`+ PyObject *self_or_null = PyStackRef_AsPyObjectBorrow(self_or_null_st);`
	`1791`	`+ fail = specialize_method_descriptor((PyMethodDescrObject *)callable,`
	`1792`	`+ self_or_null, instr, nargs);`
`1788`	`1793`	`}`
`1789`	`1794`	`else if (PyMethod_Check(callable)) {`
`1790`	`1795`	`PyObject func = ((PyMethodObject )callable)->im_func;`