builtins, code objects, gc, and typing: CPython 3.14 surface completions

AGENTS.md

@@ -143,6 +143,30 @@ The `t` is the **free-threaded** build: "CPython does X" is an answer only once
 holds without the GIL. Correct-because-a-global-lock-serialises-it is not
 on-spec.
 
+### Module presence follows PyPy
+
+**Do not implement a module that PyPy does not have merely to unskip a CPython
+test.** Whether a module exists, and which layer owns it, is part of the PyPy
+implementation shape. Before adding any builtin, extension, compatibility, or
+test-support module, verify that the real `pypy3` oracle imports it and locate
+its owner in `pypy/`, `rpython/`, or `lib_pypy/`. If neither exists, the module
+is not a pyre porting target unless the user explicitly expands the scope.
+This applies to builtin-type and CPython-test-suite sweeps too: exclude an
+absent module from the backlog instead of treating its skipped tests as missing
+implementation work. The goal is to complete PyPy's module/type surface in the
+PyPy way, not to reproduce CPython's private extension-module inventory.
+
+In particular, CPython-only test helpers such as `_testlimitedcapi` are not
+product modules. PyPy also has no `_datetime` extension module: it provides
+`datetime` through its pure-Python implementation, so pyre must preserve the
+working pure-Python path rather than invent an `_datetime` stub or accelerator.
+A CPython test that directly imports one of these absent private modules may
+skip or remain blocked; that is not by itself an implementation gap. If the
+public stdlib feature is broken, port PyPy's actual owner/fallback and fix that
+root cause. Never add an empty or partial module just to make the import
+succeed, because that suppresses the intended fallback and turns a clean skip
+into misleading failures.
+
 **The spec governs only what a caller can observe** — return value, exception
 type/message/attributes, identity, encoding-and-errors contract, accepted
 argument shapes. Everything else follows PyPy **unconditionally**: names, module

Cargo.toml

@@ -64,19 +64,22 @@ pyre-jit-trace = { version = "0.0.2", path = "pyre/pyre-jit-trace" }
 pyre-wasm = { version = "0.0.2", path = "pyre/pyre-wasm" }
 pyrex = { version = "0.0.2", path = "pyre/pyrex" }
 
-# Pinned to upstream main after the `Constants` mutable-access impls from
-# #8557 merged; `fix_code_filenames` needs `IndexMut` to edit nested code
-# constants in place.
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
-rustpython-literal = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
-rustpython-compiler = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
-rustpython-compiler-core = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
+# Pinned to upstream main after the pyre compatibility fixes from #8390 and
+# #8506, the memoryview fixes from #8553, the runtime marshal code-byte hook
+# from #8552, the `Constants` mutable-access impls from #8557, and the compiler
+# parity fixes from #8550 were merged.  `fix_code_filenames` needs `IndexMut`
+# to edit nested code constants in place, and `loads` relies on the #8552 hook
+# to preserve invalid code bytes, so this pin must not move below either.
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
+rustpython-literal = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
+rustpython-compiler = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
+rustpython-compiler-core = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
 ruff-text-size = { package = "rustpython-ruff_text_size", git = "https://github.com/RustPython/ruff.git", tag = "0.15.19-rustpython" }
 num-complex = "0.4"
-rustpython-host_env = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
-rustpython-wtf8 = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
-rustpython-unicode = { git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
-sre-engine = { package = "rustpython-sre_engine", git = "https://github.com/RustPython/RustPython.git", rev = "91a725fe833dbc06912a2619e0c39fffa0c61232" }
+rustpython-host_env = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
+rustpython-wtf8 = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
+rustpython-unicode = { git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
+sre-engine = { package = "rustpython-sre_engine", git = "https://github.com/RustPython/RustPython.git", rev = "dd2cc4d77a625661e5ca189f1cf9be199ecaa434" }
 
 # majit JIT framework
 majit = { version = "0.0.2", path = "majit/majit" }

lib-python/3/test/test_frame.py

@@ -677,6 +677,7 @@ def test_eq(self):
         pass
 
 
+@support.cpython_only
 class TestFrameCApi(unittest.TestCase):
     def test_basic(self):
         x = 1
@@ -792,6 +793,7 @@ def f():
             # Call from C, so there is a shim frame directly above f:
             weak = operator.call(f)  # BOOM!
             # Cool, we didn't crash. Check that the callback actually happened:
+            support.gc_collect()  # For PyPy or other GCs.
             self.assertIs(catcher.unraisable.exc_type, TypeError)
         self.assertIsNone(weak())
 

lib-python/3/test/test_weakref.py

@@ -1781,6 +1781,7 @@ def test_weak_valued_union_operators(self):
         self.assertIs(type(tmp4), weakref.WeakValueDictionary)
 
         del a
+        gc_collect()  # For PyPy or other GCs.
         self.assertNotIn(2, tmp1)
         self.assertNotIn(2, tmp2)
         self.assertNotIn(1, tmp3)
@@ -1833,6 +1834,7 @@ def test_weak_keyed_union_operators(self):
         self.assertIs(type(tmp4), weakref.WeakKeyDictionary)
 
         del o1
+        gc_collect()  # For PyPy or other GCs.
         self.assertNotIn(4, tmp1.values())
         self.assertNotIn(4, tmp2.values())
         self.assertNotIn(1, tmp3.values())

majit/majit-backend-wasm/js/jit_glue.js

@@ -55,8 +55,8 @@ function jitCallTrampoline(framePtr, callAreaOfs = CALL_RESULT_OFS) {
 }
 
 export function jit_compile_wasm(bytesPtr, bytesLen) {
-  const trace = instantiateTrace(bytesPtr, bytesLen);
-  return registerTrace(trace);
+  const entries = instantiateTrace(bytesPtr, bytesLen);
+  return registerTrace(entries);
 }
 
 function instantiateTrace(bytesPtr, bytesLen) {
@@ -74,16 +74,24 @@ function instantiateTrace(bytesPtr, bytesLen) {
     const instance = new WebAssembly.Instance(module, {
       env: { memory: mainMemory, jit_call: jitCallTrampoline, jit_call_compact: jitCallTrampoline, __indirect_function_table: mainTable }
     });
-    return instance.exports.trace;
+    return traceEntries(instance);
   } catch (e) {
     // Retry without jit_call (for traces without CALL ops)
     const instance = new WebAssembly.Instance(module, {
       env: { memory: mainMemory }
     });
-    return instance.exports.trace;
+    return traceEntries(instance);
   }
 }
 
+// A resumable peeled loop exports a fixed-arity `trace_wide` beside the narrow
+// `trace` shim, and the backend publishes its table slot as `handle + 1`. Both
+// hosts must therefore install the pair adjacently or that published slot names
+// an unrelated trace.
+function traceEntries(instance) {
+  return { trace: instance.exports.trace, wide: instance.exports.trace_wide };
+}
+
 // Compile and instantiate a trace, then overwrite an existing shared-table
 // slot. A caller already running the old function retains that invocation;
 // later indirect calls use the replacement.
@@ -92,11 +100,29 @@ export function jit_replace_wasm(funcId, bytesPtr, bytesLen) {
     if (!funcTable[funcId]) {
       return 0;
     }
-    const trace = instantiateTrace(bytesPtr, bytesLen);
+    const { trace, wide } = instantiateTrace(bytesPtr, bytesLen);
+    // Modules emitted while this slot was wide carry `call_indirect funcId + 1`
+    // baked in. A narrow replacement cannot retract those, so accepting one
+    // would leave the pair straddling two compiles: `funcId` on the new trace
+    // and `funcId + 1` still on the old. `funcTable` records the wide entry
+    // only when one existed, so it is the discriminator the shared table
+    // cannot be — its spare slot holds the narrow function either way. Reject
+    // the shape change before touching either table; narrow-to-wide stays
+    // allowed, mirroring the wasmtime host.
+    if (!wide && funcTable[funcId + 1] !== undefined) {
+      console.error('[jit_replace_wasm] refused: id', funcId, 'has a published wide entry the replacement does not');
+      return 0;
+    }
     if (mainTable) {
       mainTable.set(funcId, trace);
+      if (wide) {
+        mainTable.set(funcId + 1, wide);
+      }
     }
     funcTable[funcId] = trace;
+    if (wide) {
+      funcTable[funcId + 1] = wide;
+    }
     return funcId;
   } catch (e) {
     console.error('[jit_replace_wasm] failed:', e);
@@ -108,15 +134,27 @@ export function jit_replace_wasm(funcId, bytesPtr, bytesLen) {
 // table slot as the id, mirroring the wasmtime host. The slot is both the
 // jit_execute_wasm handle and the index an in-module call_indirect targets.
 // Falls back to a private counter when no table is available.
-function registerTrace(traceFn) {
+function registerTrace(entries) {
+  const { trace, wide } = entries;
   let id;
+  // The pair is appended even for a narrow module, mirroring the wasmtime
+  // host. An emitted module names its wide entry `id + 1`, and a later
+  // `jit_replace_wasm` may install one where this compile had none; without
+  // the reservation that write would land on the next trace's own entry.
   if (mainTable) {
-    id = mainTable.grow(1);
-    mainTable.set(id, traceFn);
+    id = mainTable.grow(2, trace);
+    mainTable.set(id, trace);
+    if (wide) {
+      mainTable.set(id + 1, wide);
+    }
   } else {
-    id = nextFuncId++;
+    id = nextFuncId;
+    nextFuncId += 2;
+  }
+  funcTable[id] = trace;
+  if (wide) {
+    funcTable[id + 1] = wide;
   }
-  funcTable[id] = traceFn;
   return id;
 }