runtime: Fixed various small bugs

- Issues with nested object tracking for GC
- Cleanup compile time type construction
- Fix weakref object tracking

Author: gf712

integration/tests/dict.py

@@ -45,3 +45,26 @@ def dict_setdefault():
     assert a["b"] == 10
 
 dict_setdefault()
+
+def dict_pop_missing_key_with_failing_repr():
+    # Regression: PyDict::pop formatted KeyError via key.__repr__() and
+    # unconditionally unwrapped the result, aborting if __repr__ raised.
+    class Bad:
+        def __hash__(self):
+            return 0
+        def __eq__(self, other):
+            return False
+        def __repr__(self):
+            raise ValueError("bad repr")
+
+    d = {}
+    raised = None
+    try:
+        d.pop(Bad())
+    except KeyError:
+        raised = "KeyError"
+    except ValueError:
+        raised = "ValueError"
+    assert raised is not None, "dict.pop on missing key with failing __repr__ must not abort"
+
+dict_pop_missing_key_with_failing_repr()

integration/tests/list.py

@@ -23,3 +23,13 @@
     exception_raised = True
 finally:
     assert exception_raised, "list.pop with empty list should raise an IndexError"
+
+def list_recursive_repr():
+    a = []
+    a.append(a)
+    assert repr(a) == "[[...]]", "recursive list repr should use [...] sentinel"
+    # Calling repr again must drain the visited set; otherwise nested
+    # repr() would still see `a` as visited.
+    assert repr(a) == "[[...]]", "recursive list repr should be idempotent"
+
+list_recursive_repr()

integration/tests/weakref.py

@@ -0,0 +1,64 @@
+import _weakref
+import gc
+
+# A class that supports weakrefs (built-ins like int/list typically don't).
+class Foo:
+    pass
+
+def weakref_registers_and_counts():
+    f = Foo()
+    r = _weakref.ref(f)
+    # Holding a weakref does not bump the strong-ref count, but the runtime
+    # must record the registration so weakref_count is observable.
+    assert _weakref.getweakrefcount(f) == 1
+    # The weakref still resolves to the target while the target is alive.
+    assert r() is f
+
+weakref_registers_and_counts()
+
+def weakref_resolves_through_gc_collect():
+    # gc.collect() forces a full mark/sweep regardless of cadence/pause
+    # state, so this scope can deterministically check that the weakref
+    # keeps tracking the target across collection cycles.
+    f = Foo()
+    r = _weakref.ref(f)
+    gc.collect()
+    # `f` is still on the stack here, so it must survive the collection.
+    assert r() is f
+    assert _weakref.getweakrefcount(f) == 1
+
+weakref_resolves_through_gc_collect()
+
+def gc_collect_does_not_crash_when_disabled():
+    # Disabling the GC must not prevent gc.collect() from running; this
+    # mirrors CPython's gc.collect() semantics.
+    gc.disable()
+    try:
+        assert gc.isenabled() is False
+        gc.collect()
+    finally:
+        gc.enable()
+    assert gc.isenabled() is True
+
+gc_collect_does_not_crash_when_disabled()
+
+def weakref_wrapper_unregisters_on_its_own_collection():
+    # Regression test for B8. Whenever a weakref wrapper is collected,
+    # the runtime must scrub the heap's m_weakrefs table — otherwise
+    # the per-target vector accumulates dangling pointers and
+    # getweakrefcount lies. Create N immediately-unreachable wrappers
+    # and confirm the count is zero after gc.collect(). Pre-fix this
+    # interpreter reported 100/100 survived; post-fix and on CPython
+    # (which refcounts wrappers away on the spot) it reports 0/100.
+    N = 100
+    def churn(target):
+        for _ in range(N):
+            _weakref.ref(target)  # result discarded
+    t = Foo()
+    churn(t)
+    gc.collect()
+    remaining = _weakref.getweakrefcount(t)
+    assert remaining == 0, \
+        f"expected all wrappers collected, {remaining}/{N} survived"
+
+weakref_wrapper_unregisters_on_its_own_collection()

src/runtime/PyDict.cpp

@@ -243,7 +243,14 @@ PyResult<PyObject *> PyDict::pop(PyObject *key, PyObject *default_value)
 	} else if (default_value) {
 		return Ok(default_value);
 	}
-	return Err(key_error("{}", key->repr().unwrap()->to_string()));
+	auto repr = key->repr();
+	if (repr.is_err()) {
+		// A failing user-defined __repr__ must not abort the process. Fall back
+		// to the type name so the caller still sees a KeyError rather than the
+		// unrelated repr exception.
+		return Err(key_error("<{} object>", key->type()->name()));
+	}
+	return Err(key_error("{}", repr.unwrap()->to_string()));
 }
 
 PyResult<std::monostate> PyDict::merge(PyObject *other, bool override)

src/runtime/PyFrame.cpp

@@ -141,18 +141,22 @@ PyResult<std::monostate> PyFrame::put_global(const std::string &name, const Valu
 
 PyObject *PyFrame::locals() const
 {
+	// locals() returns PyObject* and cannot propagate failures, so any
+	// errors from setitem/delitem on a non-PyDict m_locals are silently
+	// swallowed here. TODO: change locals() to PyResult<PyObject*> so
+	// __setitem__/__delitem__ exceptions surface to the caller.
 	auto insert = [this](const Value &key, const Value &value) {
 		if (auto l = as<PyDict>(m_locals)) {
 			l->insert(key, value);
 		} else {
-			m_locals->setitem(PyObject::from(key).unwrap(), PyObject::from(value).unwrap());
+			(void)m_locals->setitem(PyObject::from(key).unwrap(), PyObject::from(value).unwrap());
 		}
 	};
 	auto remove = [this](const Value &key) {
 		if (auto l = as<PyDict>(m_locals)) {
 			l->remove(key);
 		} else {
-			m_locals->delitem(PyObject::from(key).unwrap());
+			(void)m_locals->delitem(PyObject::from(key).unwrap());
 		}
 	};
 	const auto &fast_locals = VirtualMachine::the().stack_locals();

src/runtime/PyGenericAlias.cpp

@@ -94,6 +94,7 @@ PyType *PyGenericAlias::static_type() const { return types::generic_alias(); }
 
 void PyGenericAlias::visit_graph(Visitor &visitor)
 {
+	PyObject::visit_graph(visitor);
 	if (m_origin) visitor.visit(*m_origin);
 	if (m_args) visitor.visit(*m_args);
 	if (m_parameters) visitor.visit(*m_parameters);

src/runtime/PyList.cpp

@@ -33,7 +33,11 @@
 
 namespace py {
 
-static std::unordered_set<PyObject *> visited;
+// Tracks lists currently being repr'd on this thread so that cyclic structures
+// emit "[...]" instead of recursing forever. Drained by the RAII Cleanup in
+// __repr__; thread_local rather than file-scope static so concurrent
+// interpreters/threads do not see each other's in-flight repr stack.
+thread_local std::unordered_set<PyObject *> visited;
 
 template<> PyList *as(PyObject *obj)
 {
@@ -131,7 +135,9 @@ PyResult<PyObject *> PyList::extend(PyObject *iterable)
 	auto *tmp_list = tmp_list_.unwrap();
 	auto value = iterator.unwrap()->next();
 	while (value.is_ok()) {
-		tmp_list->append(value.unwrap());
+		if (auto appended = tmp_list->append(value.unwrap()); appended.is_err()) {
+			return Err(appended.unwrap_err());
+		}
 		value = iterator.unwrap()->next();
 	}