fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {

self.traceback.traverse(tracer_fn);

self.cause.traverse(tracer_fn);

self.context.traverse(tracer_fn);

self.args.traverse(tracer_fn);

}

fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

// TODO: implement more detailed, non-recursive Debug formatter

f.write_str("PyBaseException")

}

#[inline]

fn class(ctx: &Context) -> &'static Py<PyType> {

ctx.exceptions.base_exception_type

}

const PAYLOAD_TYPE_ID: core::any::TypeId = <PyException as PyPayload>::PAYLOAD_TYPE_ID;

fn supports_native_layout(layout: core::any::TypeId) -> bool {

<PyException as PyPayload>::supports_native_layout(layout)

}

const HAS_FREELIST: bool = true;

const MAX_FREELIST: usize = MEMORY_ERROR_FREELIST_SIZE;

#[inline]

unsafe fn validate_downcastable_from(obj: &PyObject) -> bool {

obj.class()

.fast_issubclass(<Self as StaticType>::static_type())

}

fn class(_ctx: &Context) -> &'static Py<PyType> {

<Self as StaticType>::static_type()

}

unsafe fn freelist_push(obj: *mut PyObject) -> bool {

let Ok(mut list) = MEMORY_ERROR_FREELIST.lock() else {

return false;

};

match list.iter_mut().find(|element| element.is_none()) {

Some(element) => {

*element = Some(MemoryErrorHusk(obj));

true

}

None => false,

}

}

unsafe fn freelist_pop(_payload: &Self) -> Option<core::ptr::NonNull<PyObject>> {

let husk = MEMORY_ERROR_FREELIST

.lock()

.ok()?

.iter_mut()

.find_map(|element| element.take())?;

core::ptr::NonNull::new(husk.0)

}

// Why `impl VirtualMachine`?

// These functions are natively free function in CPython - not methods of PyException

/// Print exception chain by calling sys.excepthook

pub fn print_exception(&self, exc: &Py<PyBaseException>) {

let vm = self;

let write_fallback = |exc, errstr| {

if let Ok(stderr) = sys::get_stderr(vm) {

let mut stderr = py_io::PyWriter(stderr, vm);

// if this fails stderr might be closed -- ignore it

let _ = writeln!(stderr, "{errstr}");

let _ = self.write_exception(&mut stderr, exc);

} else {

eprintln!("{errstr}\nlost sys.stderr");

let _ = self.write_exception(&mut py_io::IoWriter(io::stderr()), exc);

}

};

if let Ok(excepthook) = vm.sys_module.get_attr("excepthook", vm) {

let (exc_type, exc_val, exc_tb) = vm.split_exception(exc.to_owned());

if let Err(eh_exc) = excepthook.call((exc_type, exc_val, exc_tb), vm) {

write_fallback(&eh_exc, "Error in sys.excepthook:");

write_fallback(exc, "Original exception was:");

}

} else {

write_fallback(exc, "missing sys.excepthook");

}

}

pub fn write_exception<W: Write>(

&self,

output: &mut W,

exc: &Py<PyBaseException>,

) -> Result<(), W::Error> {

let seen = &mut HashSet::<usize>::new();

self.write_exception_recursive(output, exc, seen)

}

fn write_exception_recursive<W: Write>(

&self,

output: &mut W,

exc: &Py<PyBaseException>,

seen: &mut HashSet<usize>,

) -> Result<(), W::Error> {

// This function should not be called directly,

// use `wite_exception` as a public interface.

// It is similar to `print_exception_recursive` from `CPython`.

seen.insert(exc.get_id());

#[allow(clippy::manual_map)]

if let Some((cause_or_context, msg)) = if let Some(cause) = exc.__cause__() {

// This can be a special case: `raise e from e`,

// we just ignore it and treat like `raise e` without any extra steps.

Some((

cause,

"\nThe above exception was the direct cause of the following exception:\n",

))

} else if let Some(context) = exc.__context__() {

// This can be a special case:

// e = ValueError('e')

// e.__context__ = e

// In this case, we just ignore

// `__context__` part from going into recursion.

Some((

context,

"\nDuring handling of the above exception, another exception occurred:\n",

))

} else {

None

} {

if !seen.contains(&cause_or_context.get_id()) {

self.write_exception_recursive(output, &cause_or_context, seen)?;

writeln!(output, "{msg}")?;

} else {

seen.insert(cause_or_context.get_id());

}

}

self.write_exception_inner(output, exc)

}

/// Print exception with traceback

pub fn write_exception_inner<W: Write>(

&self,

output: &mut W,

exc: &Py<PyBaseException>,

) -> Result<(), W::Error> {

let vm = self;

let traceback = exc.traceback.read().clone();

if let Some(tb) = traceback {

writeln!(output, "Traceback (most recent call last):")?;

for tb in tb.iter() {

write_traceback_entry(output, &tb)?;

}

}

let varargs = exc.args();

let args_repr = vm.exception_args_as_string(&varargs, true);

let exc_class = exc.class();

if exc_class.fast_issubclass(vm.ctx.exceptions.syntax_error) {

return self.write_syntaxerror(output, exc, exc_class, &args_repr);

}

let exc_name = exc_class.name();

match args_repr.len() {

0 => write!(output, "{exc_name}"),

1 => write!(output, "{}: {}", exc_name, args_repr[0]),

_ => write!(

output,

"{}: ({})",

exc_name,

args_repr.into_iter().format(", "),

),

}?;

if let Some(suggestions) = offer_suggestions(exc, vm) {

writeln!(output, ". Did you mean: '{suggestions}'?")

} else {

writeln!(output)

}

}

/// Format and write a SyntaxError

/// This logic is derived from TracebackException._format_syntax_error

///

/// The logic has support for `end_offset` to highlight a range in the source code,

/// but it looks like `end_offset` is not used yet when SyntaxErrors are created.

fn write_syntaxerror<W: Write>(

&self,

output: &mut W,

exc: &Py<PyBaseException>,

exc_type: &Py<PyType>,

args_repr: &[PyRef<PyStr>],

) -> Result<(), W::Error> {

let vm = self;

debug_assert!(exc_type.fast_issubclass(vm.ctx.exceptions.syntax_error));

let getattr = |attr: &'static str| exc.as_object().get_attr(attr, vm).ok();

let maybe_lineno = getattr("lineno").map(|obj| {

obj.str(vm)

.unwrap_or_else(|_| vm.ctx.new_str("<lineno str() failed>"))

});

let maybe_filename = getattr("filename").and_then(|obj| obj.str(vm).ok());

let maybe_text = getattr("text").map(|obj| {

obj.str(vm)

.unwrap_or_else(|_| vm.ctx.new_str("<text str() failed>"))

});

let mut filename_suffix = String::new();

if let Some(lineno) = maybe_lineno {

let filename = match maybe_filename {

Some(filename) => filename,

None => vm.ctx.new_str("<string>"),

};

writeln!(output, r##" File "{filename}", line {lineno}"##,)?;

} else if let Some(filename) = maybe_filename {

filename_suffix = format!(" ({filename})");

}

if let Some(text) = maybe_text {

// if text ends with \n or \r\n, remove it

use rustpython_common::wtf8::CodePoint;

let text_wtf8 = text.as_wtf8();

let r_text = text_wtf8.trim_end_matches(|cp: CodePoint| {

cp == CodePoint::from_char('\n') || cp == CodePoint::from_char('\r')

});

let l_text = r_text.trim_start_matches(|cp: CodePoint| {

cp == CodePoint::from_char(' ')

|| cp == CodePoint::from_char('\n')

|| cp == CodePoint::from_char('\x0c') // \f

});

let spaces = (r_text.len() - l_text.len()) as isize;

writeln!(output, " {l_text}")?;

let maybe_offset: Option<isize> =

getattr("offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());

if let Some(offset) = maybe_offset {

let maybe_end_offset: Option<isize> =

getattr("end_offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());

let maybe_end_lineno: Option<isize> =

getattr("end_lineno").and_then(|obj| obj.try_to_value::<isize>(vm).ok());

let maybe_lineno_int: Option<isize> =

getattr("lineno").and_then(|obj| obj.try_to_value::<isize>(vm).ok());

// Only show caret if end_lineno is same as lineno (or not set)

let same_line = match (maybe_lineno_int, maybe_end_lineno) {

(Some(lineno), Some(end_lineno)) => lineno == end_lineno,

_ => true,

};

// A lone continuation at EOF has no highlighted source span.

let lone_line_continuation =

maybe_end_offset == Some(-1) && l_text.to_string_lossy() == "\\";

if same_line && !lone_line_continuation {

let mut end_offset = match maybe_end_offset {

Some(0) | None => offset,

Some(end_offset) => end_offset,

};

if offset == end_offset || end_offset == -1 {

end_offset = offset + 1;

}

// Convert 1-based column offset to 0-based index into stripped text

let colno = offset - 1 - spaces;

let end_colno = end_offset - 1 - spaces;

if colno >= 0 {

let caret_space = l_text

.code_points()

.take(colno as usize)

.map(|cp| cp.to_char().filter(|c| c.is_whitespace()).unwrap_or(' '))

.collect::<String>();

let mut error_width = end_colno - colno;

if error_width < 1 {

error_width = 1;

}

writeln!(

output,

" {}{}",

caret_space,

"^".repeat(error_width as usize)

)?;

}

}

}

}

let exc_name = exc_type.name();

match args_repr.len() {

0 => write!(output, "{exc_name}{filename_suffix}"),

1 => write!(output, "{}: {}{}", exc_name, args_repr[0], filename_suffix),

_ => write!(

output,

"{}: ({}){}",

exc_name,

args_repr.iter().format(", "),

filename_suffix

),

}?;

match offer_suggestions(exc, vm) {

Some(suggestions) => writeln!(output, ". Did you mean: '{suggestions}'?"),

None => writeln!(output),

}

}

fn exception_args_as_string(&self, varargs: &Py<PyTuple>, str_single: bool) -> Vec<PyStrRef> {

let vm = self;

match varargs.as_slice().len() {

0 => vec![],

1 => {

let args0_repr = if str_single {

varargs.as_slice()[0]

.str(vm)

.unwrap_or_else(|_| PyStr::from("<element str() failed>").into_ref(&vm.ctx))

} else {

varargs.as_slice()[0].repr(vm).unwrap_or_else(|_| {

PyStr::from("<element repr() failed>").into_ref(&vm.ctx)

})

};

vec![args0_repr]

}

_ => varargs

.as_slice()

.iter()

.map(|vararg| {

vararg.repr(vm).unwrap_or_else(|_| {

PyStr::from("<element repr() failed>").into_ref(&vm.ctx)

})

})

.collect(),

}

}

pub fn split_exception(

&self,

exc: PyBaseExceptionRef,

) -> (PyObjectRef, PyObjectRef, PyObjectRef) {

let tb = exc.traceback().to_pyobject(self);

let class = exc.class().to_owned();

(class.into(), exc.into(), tb)

}

/// Similar to PyErr_NormalizeException in CPython

pub fn normalize_exception(

&self,

exc_type: PyObjectRef,

exc_val: PyObjectRef,

exc_tb: PyObjectRef,

) -> PyResult<PyBaseExceptionRef> {

let ctor = ExceptionCtor::try_from_object(self, exc_type)?;

let exc = ctor.instantiate_value(exc_val, self)?;

if let Some(tb) = Option::<PyTracebackRef>::try_from_object(self, exc_tb)? {

exc.set_traceback(Some(tb));

}

Ok(exc)

}

pub fn invoke_exception(

&self,

cls: &Py<PyType>,

args: Vec<PyObjectRef>,

) -> PyResult<PyBaseExceptionRef> {

// TODO: fast-path built-in exceptions by directly instantiating them? Is that really worth it?

let res = PyType::call(cls, args.into_args(self), self)?;

res.downcast::<PyBaseException>().map_err(|obj| {

self.new_type_error(format!(

"calling {} should have returned an instance of BaseException, not {}",

cls,

obj.class()

))

})

}

output: &mut W,

filename: &str,

lineno: usize,

) -> Result<(), W::Error> {

// TODO: use io.open() method instead, when available, according to https://github.com/python/cpython/blob/main/Python/traceback.c#L393

// TODO: support different encodings

let file = match crate::host_env::fs::open(filename) {

Ok(file) => file,

Err(_) => return Ok(()),

};

let file = BufReader::new(file);

for (i, line) in file.lines().enumerate() {

if i + 1 == lineno {

if let Ok(line) = line {

// Indented with 4 spaces

writeln!(output, " {}", line.trim_start())?;

}

return Ok(());

}

}

Ok(())

output: &mut W,

tb_entry: &Py<PyTraceback>,

) -> Result<(), W::Error> {

let filename = tb_entry.frame.iframe().code().source_path().as_str();

writeln!(

output,

r##" File "{}", line {}, in {}"##,

filename.trim_start_matches(r"\\?\"),

tb_entry.lineno,

tb_entry.frame.iframe().code().obj_name

)?;

#[cfg(feature = "host_env")]

print_source_line(output, filename, tb_entry.lineno.get())?;

Ok(())

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

obj.downcast::<PyType>()

.and_then(|cls| {

if cls.fast_issubclass(vm.ctx.exceptions.base_exception_type) {

Ok(Self::Class(cls))

} else {

Err(cls.into())

}

})

.or_else(|obj| obj.downcast::<PyBaseException>().map(Self::Instance))

.map_err(|obj| {

vm.new_type_error(format!(

"exceptions must be classes or instances deriving from BaseException, not {}",

obj.class().name()

))

})

}

pub fn instantiate(self, vm: &VirtualMachine) -> PyResult<PyBaseExceptionRef> {

match self {

Self::Class(cls) => vm.invoke_exception(&cls, vec![]),

Self::Instance(exc) => Ok(exc),

}

}

pub fn instantiate_value(

self,

value: PyObjectRef,

vm: &VirtualMachine,

) -> PyResult<PyBaseExceptionRef> {

let exc_inst = value.clone().downcast::<PyBaseException>().ok();

match (self, exc_inst) {

// both are instances; which would we choose?

(Self::Instance(_exc_a), Some(_exc_b)) => {

Err(vm.new_type_error("instance exception may not have a separate value"))

}

// if the "type" is an instance and the value isn't, use the "type"

(Self::Instance(exc), None) => Ok(exc),

// if the value is an instance of the type, use the instance value

(Self::Class(cls), Some(exc)) if exc.fast_isinstance(&cls) => Ok(exc),

// otherwise; construct an exception of the type using the value as args

(Self::Class(cls), _) => {

let args = match_class!(match value {

PyNone => vec![],

tup @ PyTuple => tup.as_slice().to_vec(),

exc @ PyBaseException => exc.args().as_slice().to_vec(),

obj => vec![obj],

});

vm.invoke_exception(&cls, args)

}

}

}

pub base_exception_type: &'static Py<PyType>,

pub base_exception_group: &'static Py<PyType>,

pub system_exit: &'static Py<PyType>,

pub keyboard_interrupt: &'static Py<PyType>,

pub generator_exit: &'static Py<PyType>,

pub exception_type: &'static Py<PyType>,

pub stop_iteration: &'static Py<PyType>,

pub stop_async_iteration: &'static Py<PyType>,

pub arithmetic_error: &'static Py<PyType>,

pub floating_point_error: &'static Py<PyType>,

pub overflow_error: &'static Py<PyType>,

pub zero_division_error: &'static Py<PyType>,

pub assertion_error: &'static Py<PyType>,

pub attribute_error: &'static Py<PyType>,

pub buffer_error: &'static Py<PyType>,

pub eof_error: &'static Py<PyType>,

pub import_error: &'static Py<PyType>,

pub module_not_found_error: &'static Py<PyType>,

pub lookup_error: &'static Py<PyType>,

pub index_error: &'static Py<PyType>,

pub key_error: &'static Py<PyType>,

pub memory_error: &'static Py<PyType>,

pub name_error: &'static Py<PyType>,

pub unbound_local_error: &'static Py<PyType>,

pub os_error: &'static Py<PyType>,

pub blocking_io_error: &'static Py<PyType>,

pub child_process_error: &'static Py<PyType>,

pub connection_error: &'static Py<PyType>,

pub broken_pipe_error: &'static Py<PyType>,

pub connection_aborted_error: &'static Py<PyType>,

pub connection_refused_error: &'static Py<PyType>,

pub connection_reset_error: &'static Py<PyType>,

pub file_exists_error: &'static Py<PyType>,

pub file_not_found_error: &'static Py<PyType>,

pub interrupted_error: &'static Py<PyType>,

pub is_a_directory_error: &'static Py<PyType>,

pub not_a_directory_error: &'static Py<PyType>,

pub permission_error: &'static Py<PyType>,

pub process_lookup_error: &'static Py<PyType>,

pub timeout_error: &'static Py<PyType>,

pub reference_error: &'static Py<PyType>,

pub runtime_error: &'static Py<PyType>,

pub not_implemented_error: &'static Py<PyType>,

pub recursion_error: &'static Py<PyType>,

pub python_finalization_error: &'static Py<PyType>,

pub syntax_error: &'static Py<PyType>,

pub incomplete_input_error: &'static Py<PyType>,

pub indentation_error: &'static Py<PyType>,

pub tab_error: &'static Py<PyType>,

pub system_error: &'static Py<PyType>,

pub type_error: &'static Py<PyType>,

pub value_error: &'static Py<PyType>,

pub unicode_error: &'static Py<PyType>,

pub unicode_decode_error: &'static Py<PyType>,

pub unicode_encode_error: &'static Py<PyType>,

pub unicode_translate_error: &'static Py<PyType>,

#[cfg(feature = "jit")]

pub jit_error: &'static Py<PyType>,

pub warning: &'static Py<PyType>,

pub deprecation_warning: &'static Py<PyType>,

pub pending_deprecation_warning: &'static Py<PyType>,

pub runtime_warning: &'static Py<PyType>,

pub syntax_warning: &'static Py<PyType>,

pub user_warning: &'static Py<PyType>,

pub future_warning: &'static Py<PyType>,

pub import_warning: &'static Py<PyType>,

pub unicode_warning: &'static Py<PyType>,

pub bytes_warning: &'static Py<PyType>,

pub resource_warning: &'static Py<PyType>,

pub encoding_warning: &'static Py<PyType>,

(

$exc_struct:ident,

$ctx:expr,

$class:expr

) => {

extend_exception!($exc_struct, $ctx, $class, {});

};

(

$exc_struct:ident,

$ctx:expr,

$class:expr,

{ $($name:expr => $value:expr),* $(,)* }

) => {

$exc_struct::extend_class($ctx, $class);

extend_class!($ctx, $class, {

$($name => $value,)*

});

};

pub(crate) fn new(args: Vec<PyObjectRef>, vm: &VirtualMachine) -> Self {

Self {

traceback: PyRwLock::new(None),

cause: PyRwLock::new(None),

context: PyRwLock::new(None),

suppress_context: AtomicBool::new(false),

args: PyRwLock::new(PyTuple::new_ref(args, &vm.ctx)),

}

}

pub fn get_arg(&self, idx: usize) -> Option<PyObjectRef> {

self.args.read().as_slice().get(idx).cloned()

}

pub fn set_traceback(&self, traceback: Option<PyTracebackRef>) {

*self.traceback.write() = traceback;

}

pub fn set_cause(&self, cause: Option<PyRef<Self>>) {

let mut c = self.cause.write();

self.set_suppress_context(true);

*c = cause;

}

pub fn set_context(&self, context: Option<PyRef<Self>>) {

*self.context.write() = context;

}

pub(super) fn __suppress_context__(&self) -> bool {

self.suppress_context.load(Ordering::Relaxed)

}

pub(super) fn set_suppress_context(&self, suppress_context: bool) {

self.suppress_context

.store(suppress_context, Ordering::Relaxed);

}

pub fn args(&self) -> PyTupleRef {

self.args.read().clone()

}

pub fn __traceback__(&self) -> Option<PyTracebackRef> {

self.traceback.read().clone()

}

pub fn __cause__(&self) -> Option<PyRef<Self>> {

self.cause.read().clone()

}

pub fn __context__(&self) -> Option<PyRef<Self>> {

self.context.read().clone()

}

#[inline]

pub fn traceback(&self) -> Option<PyTracebackRef> {

self.__traceback__()

}

#[pymethod]

pub(super) fn __str__(&self, vm: &VirtualMachine) -> PyStrRef {

let str_args = vm.exception_args_as_string(&self.args(), true);

match str_args.into_iter().exactly_one() {

Err(i) if i.len() == 0 => vm.ctx.empty_str.to_owned(),

Ok(s) => s,

Err(i) => PyStr::from(format!("({})", i.format(", "))).into_ref(&vm.ctx),

}

}

#[pymethod]

pub fn add_note(&self, note: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {

let dict = crate::builtins::object::object_get_dict(self.as_object().to_owned(), vm)

.map_err(|_| vm.new_attribute_error("Exception object has no __dict__"))?;

let notes = if let Ok(notes) = dict.get_item("__notes__", vm) {

notes

} else {

let new_notes = vm.ctx.new_list(vec![]);

dict.set_item("__notes__", new_notes.clone().into(), vm)?;

new_notes.into()

};

let notes = notes

.downcast::<PyList>()

.map_err(|_| vm.new_type_error("Cannot add note: __notes__ is not a list"))?;

notes.borrow_vec_mut().push(note.into());

Ok(())

}

#[pymethod]

fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {

if let Some(dict) = self.as_object().dict().filter(|x| !x.is_empty()) {

vm.new_tuple((self.class().to_owned(), self.args(), dict))

} else {

vm.new_tuple((self.class().to_owned(), self.args()))

}

}