runtime: exception chaining — expose __cause__/__context__/__suppress_context__

`raise X from Y` already stored the cause on the exception
(RaiseVarargs::execute), but BaseException exposed none of the chaining
attributes, so __cause__ was unreadable.

- Add context()/set_context() and suppress_context()/set_suppress_context()
  accessors on BaseException (m_context/m_cause/m_suppress_context already
  existed and are GC-visited).
- Register __cause__, __context__ and __suppress_context__ as read/write
  properties. Setting __cause__ also sets __suppress_context__ = True, and
  __suppress_context__ coerces via truthiness, matching the data model.
- `raise X from Y` now also sets __suppress_context__ = True (and `from None`
  keeps the suppression with a None cause).

Implicit __context__ chaining (auto-setting the new exception's context to the
one being handled) is intentionally left out: the frame exception stack is not
reliably popped — internally-consumed StopIterations linger (the same
pre-existing bug that makes a bare `raise` outside a handler re-raise a stale
exception instead of erroring), so reading it would attach a spurious context.

Author: gf712

integration/tests/exception_chaining.py

@@ -0,0 +1,62 @@
+# Regression: explicit exception chaining via `raise X from Y` exposes
+# __cause__/__context__/__suppress_context__.
+#
+# NB: implicit __context__ chaining (auto-set to the exception being handled) is
+# deliberately NOT done yet — the frame exception stack isn't reliably popped
+# (internally-consumed StopIterations linger; the same bug breaks bare `raise`
+# outside a handler), so the attribute is exposed and settable but defaults to
+# None rather than being populated from that unreliable state.
+
+
+# `raise X from Y` sets __cause__ to the instance and suppresses context.
+try:
+    try:
+        raise ValueError("inner")
+    except ValueError as e:
+        raise KeyError("outer") from e
+except KeyError as k:
+    assert isinstance(k.__cause__, ValueError), k.__cause__
+    assert str(k.__cause__) == "inner", str(k.__cause__)
+    assert k.__suppress_context__ is True, k.__suppress_context__
+
+
+# `raise X from None` -> cause None, still suppressed.
+try:
+    raise KeyError("k") from None
+except KeyError as k:
+    assert k.__cause__ is None, k.__cause__
+    assert k.__suppress_context__ is True, k.__suppress_context__
+
+
+# Plain exception: all three default cleanly.
+try:
+    raise ValueError("plain")
+except ValueError as e:
+    assert e.__cause__ is None, e.__cause__
+    assert e.__context__ is None, e.__context__
+    assert e.__suppress_context__ is False, e.__suppress_context__
+
+
+# The chaining attributes are writable; setting __cause__ also suppresses context.
+try:
+    raise ValueError("x")
+except ValueError as e:
+    ctx = RuntimeError("ctx")
+    e.__context__ = ctx
+    assert e.__context__ is ctx
+    e.__cause__ = ctx
+    assert e.__cause__ is ctx
+    assert e.__suppress_context__ is True
+    e.__suppress_context__ = False
+    assert e.__suppress_context__ is False
+
+
+# `from` works with a freshly-constructed cause too.
+try:
+    raise ValueError("v") from TypeError("t")
+except ValueError as e:
+    assert isinstance(e.__cause__, TypeError), e.__cause__
+    assert str(e.__cause__) == "t", str(e.__cause__)
+
+
+print("EXCEPTION_CHAINING_OK")

src/executable/bytecode/instructions/RaiseVarargs.cpp

@@ -29,12 +29,23 @@ PyResult<Value> RaiseVarargs::execute(VirtualMachine &vm, Interpreter &) const
 		if (!exception_obj->type()->issubclass(BaseException::class_type())) {
 			return Err(type_error("exceptions must derive from BaseException"));
 		}
+		auto *raised = static_cast<BaseException *>(exception_obj);
 		if (m_cause.has_value()) {
 			auto cause = PyObject::from(vm.reg(*m_cause));
 			if (cause.is_err()) { return Err(cause.unwrap_err()); }
-			static_cast<BaseException *>(exception_obj)->set_cause(cause.unwrap());
+			// `raise X from Y` sets the explicit cause and suppresses the
+			// implicit-context display (matching the data model). `from None`
+			// keeps the suppression with a None cause.
+			raised->set_cause(cause.unwrap());
+			raised->set_suppress_context(true);
 		}
-		return Err(static_cast<BaseException *>(exception_obj));
+		// NB: implicit __context__ chaining (set the new exception's context to
+		// the one currently being handled) is intentionally NOT done here: the
+		// frame exception stack is not reliably popped (internally-consumed
+		// StopIterations linger — the same bug that makes a bare `raise` outside
+		// a handler re-raise a stale exception), so reading it would attach a
+		// spurious context. __context__ remains exposed and settable.
+		return Err(raised);
 	} else {
 		// reraise
 		if (!vm.interpreter().execution_frame()->exception_info().has_value()) {

src/runtime/BaseException.cpp

@@ -1,5 +1,6 @@
 #include "BaseException.hpp"
 #include "MemoryError.hpp"
+#include "PyBool.hpp"
 #include "PyCode.hpp"
 #include "PyFrame.hpp"
 #include "PyNone.hpp"
@@ -162,6 +163,38 @@ namespace {
 					[](BaseException *self) -> PyResult<PyObject *> {
 						return Ok(self->traceback() ? self->traceback() : py_none());
 					})
+				.property(
+					"__cause__",
+					[](BaseException *self) -> PyResult<PyObject *> {
+						return Ok(self->cause() ? self->cause() : py_none());
+					},
+					[](BaseException *self, PyObject *value) -> PyResult<std::monostate> {
+						// Per the data model, setting __cause__ also suppresses the
+						// implicit context display (raise ... from ...).
+						self->set_cause(value == py_none() ? nullptr : value);
+						self->set_suppress_context(true);
+						return Ok(std::monostate{});
+					})
+				.property(
+					"__context__",
+					[](BaseException *self) -> PyResult<PyObject *> {
+						return Ok(self->context() ? self->context() : py_none());
+					},
+					[](BaseException *self, PyObject *value) -> PyResult<std::monostate> {
+						self->set_context(value == py_none() ? nullptr : value);
+						return Ok(std::monostate{});
+					})
+				.property(
+					"__suppress_context__",
+					[](BaseException *self) -> PyResult<PyObject *> {
+						return Ok(self->suppress_context() ? py_true() : py_false());
+					},
+					[](BaseException *self, PyObject *value) -> PyResult<std::monostate> {
+						auto truthy = value->true_();
+						if (truthy.is_err()) { return Err(truthy.unwrap_err()); }
+						self->set_suppress_context(truthy.unwrap());
+						return Ok(std::monostate{});
+					})
 				.type);
 	}
 }// namespace

src/runtime/BaseException.hpp

@@ -48,6 +48,12 @@ class BaseException : public PyBaseObject
 	PyObject *cause() const { return m_cause; }
 	void set_cause(PyObject *cause) { m_cause = cause; }
 
+	PyObject *context() const { return m_context; }
+	void set_context(PyObject *context) { m_context = context; }
+
+	bool suppress_context() const { return m_suppress_context; }
+	void set_suppress_context(bool suppress) { m_suppress_context = suppress; }
+
 	std::string format_traceback() const;
 
 	static std::function<std::unique_ptr<TypePrototype>()> type_factory();