René's URL Explorer Experiment

{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"vectercall per type","articleBody":"# Support per-type-instance vectorcall for builtin types (dict, list, int, ...)\n\n## Summary\n\nCurrently, all type-object constructor calls (e.g. `dict(x=1)`, `list([1,2,3])`, `int(\"42\")`) go through a single `vectorcall_type` function, which only has a fast path for `type(x)` and falls back to the generic `PyType::call` slow path for everything else. This means every builtin type constructor pays the cost of `slot_new(args.clone())` + `slot_init(args)` dispatch, including an unnecessary `args.clone()`.\n\nCPython avoids this by giving each `PyTypeObject` its own `tp_vectorcall` function pointer. When you call `dict(...)`, CPython reads `PyDict_Type.tp_vectorcall` (= `dict_vectorcall`) directly, bypassing the generic `type.__call__` → `__new__` + `__init__` chain entirely. Over 15 builtin types have dedicated vectorcall implementations.\n\n## Current Architecture in RustPython\n\n```\ndict(x=1)\n  → PyCallable::new(dict_type_obj)\n  → obj.class() = type (metatype)\n  → type.slots.vectorcall = vectorcall_type\n  → vectorcall_type: not type(x), so fallback\n  → PyType::call(dict_type, args)\n    → slot_new(args.clone())    ← unnecessary clone\n    → slot_init(args)\n```\n\nEach `PyType` instance already has its own `slots: PyTypeSlots` with `vectorcall: AtomicCell\u003cOption\u003cVectorCallFunc\u003e\u003e`, but the dispatch path never reads it. `vectorcall_type` receives the type object as its first argument but ignores the type's own `slots.vectorcall`.\n\n## Proposed Solution\n\n### 1. Modify `vectorcall_type` to dispatch per-type vectorcall\n\nIn `crates/vm/src/builtins/type.rs`, add a branch that checks the called type's own `slots.vectorcall`:\n\n```rust\nfn vectorcall_type(...) -\u003e PyResult {\n    let zelf: \u0026Py\u003cPyType\u003e = zelf_obj.downcast_ref().unwrap();\n\n    if zelf.is(vm.ctx.types.type_type) {\n        // type(x) fast path (existing)\n        ...\n    } else if let Some(type_vc) = zelf.slots.vectorcall.load() {\n        // Per-type vectorcall: dict_vectorcall, list_vectorcall, etc.\n        return type_vc(zelf_obj, args, nargs, kwnames, vm);\n    }\n\n    // Fallback to PyType::call\n    ...\n}\n```\n\nThe `else if` structure prevents infinite recursion: when `zelf` is `type_type` itself, we never read `zelf.slots.vectorcall` (which would be `vectorcall_type` again).\n\n### 2. Clear vectorcall on `__init__`/`__new__` override\n\nIn `crates/vm/src/types/slot.rs`, when `update_slot` processes `TpInit` or `TpNew` with `ADD=true`, also clear `self.slots.vectorcall.store(None)`.\n\nThis ensures subclasses that override `__init__` or `__new__` don't inherit an incorrect per-type vectorcall. For example, `class MyDict(dict): def __init__(self, ...): ...` must NOT use `dict_vectorcall`, which would skip the Python `__init__` override.\n\n### 3. Implement and register per-type vectorcall functions\n\nEach builtin type gets a dedicated vectorcall function registered in its `init()`:\n\n| Type | File | Pattern |\n|------|------|---------|\n| `dict` | `builtins/dict.rs` | DefaultConstructor + Initializer (skip `slot_new`, pass args only to `slot_init`) |\n| `list` | `builtins/list.rs` | Constructor |\n| `tuple` | `builtins/tuple.rs` | Constructor |\n| `int` | `builtins/int.rs` | Constructor |\n| `float` | `builtins/float.rs` | Constructor |\n| `str` | `builtins/pystr.rs` | Constructor |\n| `bool` | `builtins/bool_.rs` | Constructor |\n| `set` | `builtins/set.rs` | DefaultConstructor + Initializer |\n| `frozenset` | `builtins/set.rs` | Constructor |\n\nThe key optimization for `DefaultConstructor + Initializer` types (like `dict`, `set`) is avoiding the `args.clone()` in `PyType::call` line 2216 — since `Default::default()` needs no args, we construct the object first, then pass args only to `slot_init`.\n\n## Inheritance Behavior\n\n- Vectorcall is already inherited alongside `call` via `copyslot_if_none` in `slot_defs.rs` (lines 574-577)\n- `class MyDict(dict): pass` → inherits `dict_vectorcall` ✓\n- `class MyDict(dict): def __init__(self, ...): ...` → vectorcall cleared to `None`, falls back to `PyType::call` ✓\n- Custom metaclass with `__call__` override → vectorcall cleared on metaclass, per-type vectorcall never reached ✓\n\n## Key Files\n\n- `crates/vm/src/builtins/type.rs` — `vectorcall_type` dispatch modification\n- `crates/vm/src/types/slot.rs` — `update_slot` vectorcall clearing for TpInit/TpNew\n- `crates/vm/src/types/slot_defs.rs` — `copyslot_if_none` inheritance (already correct)\n- `crates/vm/src/protocol/callable.rs` — `PyCallable::new` (no changes needed)\n- Individual builtin type files for vectorcall implementations\n\n## References\n\n- [PEP 590 – Vectorcall: a fast calling protocol for CPython](https://peps.python.org/pep-0590/)\n- CPython `Objects/typeobject.c`: `type_vectorcall`, `inherit_special`\n- CPython `Include/internal/pycore_call.h`: `_PyVectorcall_FunctionInline`, `_PyObject_VectorcallTstate`","author":{"url":"https://github.com/youknowone","@type":"Person","name":"youknowone"},"datePublished":"2026-03-05T19:54:57.000Z","interactionStatistic":{"@type":"InteractionCounter","interactionType":"https://schema.org/CommentAction","userInteractionCount":0},"url":"https://github.com/7362/RustPython/issues/7362"}