gh-86199: Avoid an unnecessary dict copy for f(**kwargs) calls

Since Python 3.9 a call with a lone ** unpacking compiled to
BUILD_MAP 0 + DICT_MERGE 1 + CALL_FUNCTION_EX, copying the kwargs dict on
every call.  For vectorcall callees (all Python functions and most
builtins) that copy is wasted work: the dict is immediately unpacked onto
a flat argument vector.

The compiler now pushes the ** operand as-is.  CALL_FUNCTION_EX converts a
non-exact mapping to a dict itself (reusing the DICT_MERGE machinery, so
error messages are unchanged), and PyObject_Call copies the dict only on
the tp_call path, where the callee would otherwise receive the caller's
dict directly -- so a callee still can never mutate the caller's kwargs,
and the documented PyObject_Call/callable(*args, **kwargs) equivalence now
holds for the C API too (gh-86795).

_PyStack_UnpackDict takes a critical section while copying the dict's
items out, retrying if the dict was resized in between, which makes
unpacking a shared dict safe on free-threaded builds.

f(**d) with a small dict is ~1.4x faster; calls without ** unpacking are
unaffected.

Co-authored-by: Josh Rosenberg <1178095+MojoVampire@users.noreply.github.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: 3 people

Lib/test/test_call.py

@@ -95,6 +95,30 @@ def test_kwargs_order_preserved_in_c_functions(self):
         self.assertEqual(list(collections.OrderedDict(b=1, a=2, c=3)),
                          ['b', 'a', 'c'])
 
+    def test_kwargs_unpacking_mutation_isolated(self):
+        # gh-86199: a callee mutating its **kwargs must never affect the
+        # caller's dict.
+        def fn(**kw):
+            kw['injected'] = None
+        d = {'a': 1}
+        fn(**d)
+        self.assertEqual(d, {'a': 1})
+        e = {}
+        fn(**e)
+        self.assertEqual(e, {})
+
+    @cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_kwargs_unpacking_not_aliased_in_tp_call(self):
+        # gh-86199: a tp_call callee receives a private copy of the kwargs
+        # dict, never the caller's dict.
+        get_kwargs = _testcapi.get_kwargs  # METH_VARARGS | METH_KEYWORDS
+        d = {'a': 1}
+        self.assertIsNot(get_kwargs(**d), d)
+        self.assertEqual(get_kwargs(**d), d)
+        e = {}
+        self.assertIsNot(get_kwargs(**e), e)
+
     def test_frames_are_popped_after_failed_calls(self):
         # GH-93252: stuff blows up if we don't pop the new frame after
         # recovering from failed calls:

Lib/test/test_free_threading/test_kwargs_unpack.py

@@ -0,0 +1,45 @@
+import unittest
+from unittest import TestCase
+
+from test.support import threading_helper, import_helper
+
+_testcapi = import_helper.import_module("_testcapi")
+
+threading_helper.requires_working_threading(module=True)
+
+
+class TestKwargsUnpackRace(TestCase):
+    def test_mutate_kwargs_during_unpack(self):
+        # gh-86199: unpacking a shared kwargs dict must tolerate another
+        # thread resizing it.
+        num_mutators, num_callers = 2, 6
+        iters = 1000
+        min_keys, max_keys = 4, 3000
+
+        fastcalldict = _testcapi.pyobject_fastcalldict
+
+        def target(**kwargs):
+            return len(kwargs)
+
+        shared = {f"k{i}": i for i in range(min_keys)}
+
+        def resize_kwargs():
+            for _ in range(iters):
+                for i in range(min_keys, max_keys):
+                    shared[f"k{i}"] = i
+                for i in range(max_keys - 1, min_keys - 1, -1):
+                    shared.pop(f"k{i}", None)
+
+        def call_target():
+            for _ in range(iters):
+                try:
+                    fastcalldict(target, (), shared)
+                except Exception:
+                    pass
+
+        threading_helper.run_concurrently(
+            [resize_kwargs] * num_mutators + [call_target] * num_callers)
+
+
+if __name__ == "__main__":
+    unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2026-08-24-23-59-00.gh-issue-86199.pQk3vX.rst

@@ -0,0 +1,6 @@
+Speed up calls of the form ``f(**kwargs)`` by no longer always copying the
+keyword arguments before the call; such calls are now up to 1.4x faster.
+This also fixes :c:func:`PyObject_Call` to copy the keyword arguments before
+passing them to a callee that would otherwise receive the caller's dict, so a
+called object can no longer mutate the caller's dict (:gh:`86795`), and makes
+unpacking a shared keyword-arguments dict safe on the free-threaded build.