⚠️ Potential issue | 🟠 Major

🌐 Web query:

CPython 3.14 SimpleNamespace.__replace__ implementation behavior kwargs constructor

💡 Result:

Short answer: SimpleNamespace.replace (used by copy.replace()) creates a new instance by calling the SimpleNamespace constructor with the current namespace contents as the initial mapping/positional argument and applying the replace keyword arguments on top, so replacement kwargs override existing keys. See the SimpleNamespace constructor docs (mapping_or_iterable=(), /, **kwargs) and the copy.replace description in the 3.13+ changes. [1][2]

Sources

• types.SimpleNamespace docs (constructor behavior: optional positional mapping/iterable then **kwargs; kwargs update afterwards). [1]
• What's new / copy.replace description (copy.replace uses replace; SimpleNamespace is supported). [2]

Fix replace to pass attributes through constructor to match CPython behavior.

Line 54 calls cls.call((), vm) with no arguments, then manually copies the namespace dict and applies kwargs via set_attr. This bypasses the constructor and doesn't match CPython 3.14 behavior. In CPython, SimpleNamespace.__replace__ passes the current namespace contents as a positional mapping argument and the replacement kwargs as **kwargs to the constructor. This allows subclasses with __init__ validation or custom logic to properly process the merged attributes. Pass the current namespace dict as a positional argument and the replacement kwargs to cls.call() instead of constructing an empty instance and mutating __dict__ afterward.

In `@crates/vm/src/builtins/namespace.rs` around lines 46 - 69, The __replace__
implementation currently calls cls.call((), vm) then mutates the new instance's
__dict__; instead, build a mapping from the current namespace (src_dict) and
call the constructor with that mapping as the single positional argument and the
replacement kwargs (args.kwargs) as **kwargs so subclasses' __init__ runs
normally. Concretely, stop creating result then copying src_dict and calling
set_attr; instead prepare a positional tuple containing the namespace mapping
and pass args.kwargs into cls.call(...) so cls.call receives (mapping,) and the
kwargs, preserving existing checks for positional args and using the same
vm/context objects (referencing __replace__, cls.call, zelf, src_dict, and
args.kwargs).

incorrect

🌐 Web query:

CPython SimpleNamespace __replace__ source code implementation

💡 Result:

The SimpleNamespace replace implementation is in CPython’s C source: see Objects/namespaceobject.c in the CPython repository (types.SimpleNamespace is implemented there). The copy.replace protocol and that SimpleNamespace supports it are documented in the copy module docs and the types docs. References:

• CPython source (namespaceobject.c). [1]
• copy.replace / replace documentation. [2]
• types.SimpleNamespace (docs noting support for copy.replace). [3]

References

1. Objects/namespaceobject.c — CPython source (types.SimpleNamespace implementation). [turn9view0].
2. Doc: copy.replace and object.replace (copy module docs). [turn3search3].
3. Doc: types.SimpleNamespace (notes it’s supported by copy.replace). [turn10search0].

🌐 Web query:

CPython namespaceobject.c __replace__ method implementation details

💡 Result:

Short answer: In CPython the SimpleNamespace replace is implemented in C (Objects/namespaceobject.c). It accepts keyword arguments, copies the namespace's dict, updates that copy with the provided keyword changes, constructs and returns a new SimpleNamespace whose dict is the updated dict (leaving the original instance unchanged). This is the mechanism used to support the new copy.replace()/object.replace protocol added for Python 3.13. See the Python 3.13 notes and the checkin adding object.replace documentation. [1][2]

References

• Python 3.13 "copy.replace" / object.replace description. [1]
• Python checkins (Doc/library/copy.rst change mentioning object.replace, Python 3.13). [2]

🏁 Script executed:

#!/bin/bash
# Fetch the actual CPython source code for SimpleNamespace __replace__ implementation
curl -s "https://raw.githubusercontent.com/python/cpython/v3.14.2/Objects/namespaceobject.c" | grep -A 50 "__replace__" | head -60

Length of output: 2424

@youknowone, you're absolutely right—I apologize for the incorrect suggestion.

I've now reviewed the actual CPython 3.14.2 source code from Objects/namespaceobject.c. The CPython implementation:

1. Rejects positional arguments with _PyArg_NoPositional
2. Creates a new empty instance via PyObject_CallNoArgs((PyObject *)Py_TYPE(self))
3. Updates the new instance's __dict__ from the original instance via PyDict_Update
4. Updates the new instance's __dict__ with the kwargs if provided

Your Rust implementation correctly mirrors this behavior by calling cls.call((), vm) with no arguments, then copying the dict and applying kwargs. The claim that CPython passes namespace contents as a positional argument to the constructor was wrong.

Learnt from: youknowone
Repo: RustPython/RustPython PR: 6797
File: crates/vm/src/builtins/namespace.rs:46-69
Timestamp: 2026-01-20T02:02:14.639Z
Learning: In RustPython's SimpleNamespace implementation (crates/vm/src/builtins/namespace.rs), the __replace__ method correctly creates a new empty instance via cls.call((), vm) then mutates its dict, matching CPython's pattern of calling PyObject_CallNoArgs then updating __dict__ directly. Do not suggest passing existing namespace contents as positional arguments to the constructor.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.