Merge pull request #3131 from youknowone/exc-builtins

Expose exception types under vm::builtins

derive/src/pyclass.rs

@@ -346,7 +346,7 @@ pub(crate) fn impl_define_exception(
 
             #[pymethod(magic)]
             pub(crate) fn init(
-                zelf: ::rustpython_vm::PyRef<::rustpython_vm::exceptions::PyBaseException>,
+                zelf: ::rustpython_vm::PyRef<::rustpython_vm::builtins::PyBaseException>,
                 args: ::rustpython_vm::function::FuncArgs,
                 vm: &::rustpython_vm::VirtualMachine,
             ) -> ::rustpython_vm::PyResult<()> {

src/shell.rs

@@ -3,8 +3,9 @@ mod helper;
 use rustpython_parser::error::{LexicalErrorType, ParseErrorType};
 use rustpython_vm::readline::{Readline, ReadlineResult};
 use rustpython_vm::{
+    builtins::PyBaseExceptionRef,
     compile::{self, CompileError, CompileErrorType},
-    exceptions::{print_exception, PyBaseExceptionRef},
+    exceptions::print_exception,
     scope::Scope,
     PyResult, TypeProtocol, VirtualMachine,
 };

vm/src/builtins/asyncgenerator.rs

@@ -1,7 +1,7 @@
 use super::{PyCode, PyStrRef, PyTypeRef};
 use crate::{
+    builtins::PyBaseExceptionRef,
     coroutine::{Coro, Variant},
-    exceptions::PyBaseExceptionRef,
     frame::FrameRef,
     function::OptionalArg,
     slots::{IteratorIterable, PyIter},

vm/src/builtins/dict.rs

@@ -1,8 +1,8 @@
 use super::{IterStatus, PySet, PyStrRef, PyTypeRef};
 use crate::{
+    builtins::PyBaseExceptionRef,
     common::ascii,
     dictdatatype::{self, DictKey},
-    exceptions::PyBaseExceptionRef,
     function::{ArgIterable, FuncArgs, KwArgs, OptionalArg},
     iterator,
     slots::{Comparable, Hashable, Iterable, IteratorIterable, PyComparisonOp, PyIter, Unhashable},

vm/src/builtins/function/jitfunc.rs

@@ -1,12 +1,9 @@
-use crate::builtins::dict::PyDictRef;
-use crate::builtins::function::{PyFunction, PyFunctionRef};
-use crate::builtins::{float, int, pybool, PyStrRef};
-use crate::bytecode::CodeFlags;
-use crate::exceptions::PyBaseExceptionRef;
-use crate::function::FuncArgs;
-use crate::VirtualMachine;
 use crate::{
-    IdProtocol, IntoPyObject, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol,
+    builtins::{float, int, pybool, PyBaseExceptionRef, PyDictRef, PyFunction, PyStrRef},
+    bytecode::CodeFlags,
+    function::FuncArgs,
+    IdProtocol, IntoPyObject, ItemProtocol, PyObjectRef, PyRef, PyResult, TryFromObject,
+    TypeProtocol, VirtualMachine,
 };
 use num_traits::ToPrimitive;
 use rustpython_jit::{AbiValue, Args, CompiledCode, JitArgumentError, JitType};
@@ -66,7 +63,7 @@ fn get_jit_arg_type(dict: &PyDictRef, name: &str, vm: &VirtualMachine) -> PyResu
     }
 }
 
-pub fn get_jit_arg_types(func: &PyFunctionRef, vm: &VirtualMachine) -> PyResult<Vec<JitType>> {
+pub fn get_jit_arg_types(func: &PyRef<PyFunction>, vm: &VirtualMachine) -> PyResult<Vec<JitType>> {
     let arg_names = func.code.arg_names();
 
     if func

vm/src/builtins/mod.rs

@@ -86,3 +86,5 @@ pub use int::try_to_float as try_bigint_to_f64;
 
 mod make_module;
 pub use make_module::{ascii, make_module, print};
+
+pub use crate::exceptions::types::*;

vm/src/builtins/singletons.rs

@@ -1,13 +1,12 @@
 use super::PyTypeRef;
 use crate::{
-    slots::SlotConstructor, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult,
-    PyValue, TypeProtocol, VirtualMachine,
+    slots::SlotConstructor, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyResult, PyValue,
+    TypeProtocol, VirtualMachine,
 };
 
 #[pyclass(module = false, name = "NoneType")]
 #[derive(Debug)]
 pub struct PyNone;
-pub type PyNoneRef = PyRef<PyNone>;
 
 impl PyValue for PyNone {
     fn class(vm: &VirtualMachine) -> &PyTypeRef {

vm/src/codecs.rs

@@ -1,13 +1,13 @@
+use crate::{
+    builtins::{PyBaseExceptionRef, PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef},
+    common::{ascii, lock::PyRwLock},
+    IntoPyObject, PyContext, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol,
+    VirtualMachine,
+};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::ops::Range;
 
-use crate::builtins::{PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef};
-use crate::common::{ascii, lock::PyRwLock};
-use crate::exceptions::PyBaseExceptionRef;
-use crate::VirtualMachine;
-use crate::{IntoPyObject, PyContext, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol};
-
 pub struct CodecsRegistry {
     inner: PyRwLock<RegistryInner>,
 }

vm/src/coroutine.rs

@@ -1,10 +1,10 @@
-use crate::builtins::{PyStrRef, PyTypeRef};
-use crate::exceptions::{self, PyBaseExceptionRef};
-use crate::frame::{ExecutionResult, FrameRef};
-use crate::VirtualMachine;
-use crate::{PyObjectRef, PyResult, TypeProtocol};
-
-use crate::common::lock::PyMutex;
+use crate::{
+    builtins::{PyBaseExceptionRef, PyStrRef, PyTypeRef},
+    common::lock::PyMutex,
+    exceptions,
+    frame::{ExecutionResult, FrameRef},
+    PyObjectRef, PyResult, TypeProtocol, VirtualMachine,
+};
 use crossbeam_utils::atomic::AtomicCell;
 
 #[derive(Debug, PartialEq, Clone, Copy)]

vm/src/format.rs

@@ -1,9 +1,10 @@
-use crate::builtins::{self, PyStrRef};
-use crate::common::float_ops;
-use crate::exceptions::{IntoPyException, PyBaseExceptionRef};
-use crate::function::FuncArgs;
-use crate::vm::VirtualMachine;
-use crate::{ItemProtocol, PyObjectRef, PyResult, TypeProtocol};
+use crate::{
+    builtins::{self, PyBaseExceptionRef, PyStrRef},
+    common::float_ops,
+    exceptions::IntoPyException,
+    function::FuncArgs,
+    ItemProtocol, PyObjectRef, PyResult, TypeProtocol, VirtualMachine,
+};
 use itertools::{Itertools, PeekingNext};
 use num_bigint::{BigInt, Sign};
 use num_traits::cast::ToPrimitive;

vm/src/frame.rs

@@ -1,5 +1,6 @@
 use crate::common::{boxvec::BoxVec, lock::PyMutex};
 use crate::{
+    builtins::PyBaseExceptionRef,
     builtins::{
         self,
         asyncgenerator::PyAsyncGenWrappedValue,
@@ -13,7 +14,7 @@ use crate::{
     },
     bytecode,
     coroutine::Coro,
-    exceptions::{self, ExceptionCtor, PyBaseExceptionRef},
+    exceptions::{self, ExceptionCtor},
     function::FuncArgs,
     iterator,
     scope::Scope,

vm/src/function.rs

@@ -2,13 +2,10 @@ mod argument;
 mod byteslike;
 
 use self::OptionalArg::*;
-use crate::builtins::pytype::PyTypeRef;
-use crate::builtins::tuple::PyTupleRef;
-use crate::exceptions::PyBaseExceptionRef;
-use crate::vm::VirtualMachine;
 use crate::{
+    builtins::{PyBaseExceptionRef, PyTupleRef, PyTypeRef},
     IntoPyObject, IntoPyResult, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue,
-    TryFromObject, TypeProtocol,
+    TryFromObject, TypeProtocol, VirtualMachine,
 };
 use indexmap::IndexMap;
 use itertools::Itertools;

vm/src/import.rs

@@ -1,18 +1,16 @@
 /*
  * Import mechanics
  */
-use rand::Rng;
-
-use crate::builtins::code::CodeObject;
-use crate::builtins::traceback::{PyTraceback, PyTracebackRef};
-use crate::builtins::{code, list};
 #[cfg(feature = "rustpython-compiler")]
 use crate::compile;
-use crate::exceptions::PyBaseExceptionRef;
-use crate::scope::Scope;
-use crate::version::get_git_revision;
-use crate::vm::{InitParameter, VirtualMachine};
-use crate::{ItemProtocol, PyResult, PyValue, TryFromObject, TypeProtocol};
+use crate::{
+    builtins::{code, code::CodeObject, list, traceback::PyTraceback, PyBaseExceptionRef},
+    scope::Scope,
+    version::get_git_revision,
+    vm::{InitParameter, VirtualMachine},
+    ItemProtocol, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
+};
+use rand::Rng;
 
 pub(crate) fn init_importlib(
     vm: &mut VirtualMachine,
@@ -146,9 +144,9 @@ pub fn import_codeobj(
 
 fn remove_importlib_frames_inner(
     vm: &VirtualMachine,
-    tb: Option<PyTracebackRef>,
+    tb: Option<PyRef<PyTraceback>>,
     always_trim: bool,
-) -> (Option<PyTracebackRef>, bool) {
+) -> (Option<PyRef<PyTraceback>>, bool) {
     let traceback = if let Some(tb) = tb {
         tb
     } else {

vm/src/iterator.rs

@@ -4,7 +4,7 @@
 
 use crate::builtins::int::{self, PyInt};
 use crate::builtins::iter::PySequenceIterator;
-use crate::exceptions::PyBaseExceptionRef;
+use crate::builtins::PyBaseExceptionRef;
 use crate::vm::VirtualMachine;
 use crate::{IdProtocol, PyObjectRef, PyResult, PyValue, TypeProtocol};
 use num_traits::Signed;

vm/src/py_io.rs

@@ -1,9 +1,8 @@
-use crate::builtins::bytes::PyBytes;
-use crate::builtins::pystr::PyStr;
-use crate::common::ascii;
-use crate::exceptions::PyBaseExceptionRef;
-use crate::VirtualMachine;
-use crate::{PyObjectRef, PyResult};
+use crate::{
+    builtins::{PyBaseExceptionRef, PyBytes, PyStr},
+    common::ascii,
+    PyObjectRef, PyResult, VirtualMachine,
+};
 use std::{fmt, io, ops};
 
 pub trait Write {

vm/src/pyobject.rs

@@ -5,6 +5,7 @@ use crate::common::{
 };
 pub use crate::pyobjectrc::{PyObject, PyObjectRef, PyObjectWeak, PyRef, PyWeakRef};
 use crate::{
+    builtins::PyBaseExceptionRef,
     builtins::{
         builtinfunc::PyNativeFuncDef,
         bytearray, bytes,
@@ -17,7 +18,7 @@ use crate::{
         PyNone, PyNotImplemented, PyStaticMethod, PyTuple, PyTupleRef, PyType, PyTypeRef,
     },
     dictdatatype::Dict,
-    exceptions::{self, PyBaseExceptionRef},
+    exceptions,
     function::{IntoFuncArgs, IntoPyNativeFunc},
     slots::{PyTpFlags, PyTypeSlots},
     types::{create_type_with_slots, TypeZoo},

vm/src/stdlib/codecs.rs

@@ -4,9 +4,8 @@ pub(crate) use _codecs::make_module;
 mod _codecs {
     use crate::common::encodings;
     use crate::{
-        builtins::{PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple},
+        builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple},
         codecs,
-        exceptions::PyBaseExceptionRef,
         function::{ArgBytesLike, FuncArgs},
         IdProtocol, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
     };

vm/src/stdlib/io.rs

@@ -78,11 +78,13 @@ mod _io {
     };
     use crate::{
         builtins::{
-            PyByteArray, PyBytes, PyBytesRef, PyMemoryView, PyStr, PyStrRef, PyType, PyTypeRef,
+            PyBaseExceptionRef, PyByteArray, PyBytes, PyBytesRef, PyMemoryView, PyStr, PyStrRef,
+            PyType, PyTypeRef,
+        },
+        exceptions,
+        function::{
+            ArgBytesLike, ArgIterable, ArgMemoryBuffer, FuncArgs, OptionalArg, OptionalOption,
         },
-        exceptions::{self, PyBaseExceptionRef},
-        function::{ArgBytesLike, ArgMemoryBuffer},
-        function::{ArgIterable, FuncArgs, OptionalArg, OptionalOption},
         protocol::{BufferInternal, BufferOptions, PyBuffer, ResizeGuard},
         slots::{Iterable, PyIter, SlotConstructor},
         utils::Either,

vm/src/stdlib/json.rs

@@ -5,8 +5,8 @@ mod machinery;
 mod _json {
     use super::machinery;
     use crate::{
+        builtins::PyBaseExceptionRef,
         builtins::{PyStrRef, PyTypeRef},
-        exceptions::PyBaseExceptionRef,
         function::{FuncArgs, OptionalArg},
         iterator,
         slots::{Callable, SlotConstructor},

vm/src/stdlib/os.rs

@@ -1,8 +1,9 @@
 use super::errno::errors;
 use crate::crt_fd::Fd;
 use crate::{
+    builtins::PyBaseExceptionRef,
     builtins::{PyBytes, PyBytesRef, PyInt, PySet, PyStr, PyStrRef},
-    exceptions::{IntoPyException, PyBaseExceptionRef},
+    exceptions::IntoPyException,
     function::{ArgumentError, FromArgs, FuncArgs},
     protocol::PyBuffer,
     IntoPyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject,

vm/src/stdlib/pystruct.rs

@@ -13,11 +13,10 @@
 pub(crate) mod _struct {
     use crate::{
         builtins::{
-            bytes::PyBytesRef, float, pybool::IntoPyBool, pystr::PyStr, pystr::PyStrRef,
-            pytype::PyTypeRef, tuple::PyTupleRef,
+            float, IntoPyBool, PyBaseExceptionRef, PyBytesRef, PyStr, PyStrRef, PyTupleRef,
+            PyTypeRef,
         },
         common::str::wchar_t,
-        exceptions::PyBaseExceptionRef,
         function::{ArgBytesLike, ArgMemoryBuffer, PosArgs},
         slots::{IteratorIterable, PyIter, SlotConstructor},
         utils::Either,

vm/src/stdlib/socket.rs

@@ -1,7 +1,7 @@
 use crate::common::lock::{PyMappedRwLockReadGuard, PyRwLock, PyRwLockReadGuard};
 use crate::{
-    builtins::{PyStrRef, PyTupleRef, PyTypeRef},
-    exceptions::{IntoPyException, PyBaseExceptionRef},
+    builtins::{PyBaseExceptionRef, PyStrRef, PyTupleRef, PyTypeRef},
+    exceptions::IntoPyException,
     function::{ArgBytesLike, ArgMemoryBuffer, FuncArgs, OptionalArg, OptionalOption},
     utils::{Either, ToCString},
     IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject,

vm/src/stdlib/ssl.rs

@@ -4,10 +4,9 @@ use crate::common::{
     lock::{PyRwLock, PyRwLockWriteGuard},
 };
 use crate::{
-    builtins::{PyStrRef, PyType, PyTypeRef, PyWeak},
-    exceptions::{self, IntoPyException, PyBaseException, PyBaseExceptionRef},
-    function::{ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike},
-    function::{ArgCallable, OptionalArg},
+    builtins::{PyBaseException, PyBaseExceptionRef, PyStrRef, PyType, PyTypeRef, PyWeak},
+    exceptions::{self, IntoPyException},
+    function::{ArgBytesLike, ArgCallable, ArgMemoryBuffer, ArgStrOrBytesLike, OptionalArg},
     slots::SlotConstructor,
     stdlib::os::PyPathLike,
     types::create_simple_type,

vm/src/stdlib/termios.rs

@@ -3,8 +3,8 @@ pub(crate) use self::termios::make_module;
 #[pymodule]
 mod termios {
     use crate::{
+        builtins::PyBaseExceptionRef,
         builtins::{PyBytes, PyInt, PyListRef, PyTypeRef},
-        exceptions::PyBaseExceptionRef,
         IntoPyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
     };
     use std::convert::TryFrom;

vm/src/stdlib/zlib.rs

@@ -4,8 +4,7 @@ pub(crate) use decl::make_module;
 mod decl {
     use crate::common::lock::PyMutex;
     use crate::{
-        builtins::{PyBytes, PyBytesRef, PyIntRef, PyTypeRef},
-        exceptions::PyBaseExceptionRef,
+        builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyIntRef, PyTypeRef},
         function::{ArgBytesLike, OptionalArg},
         types::create_simple_type,
         IntoPyRef, PyResult, PyValue, VirtualMachine,

vm/src/vm.rs

@@ -14,10 +14,11 @@ use crate::{
         tuple::{PyTuple, PyTupleRef, PyTupleTyped},
         PyDictRef, PyInt, PyIntRef, PyList, PyModule, PyStr, PyStrRef, PyTypeRef,
     },
+    builtins::{PyBaseException, PyBaseExceptionRef},
     bytecode,
     codecs::CodecsRegistry,
     common::{ascii, hash::HashSecret, lock::PyMutex, rc::PyRc},
-    exceptions::{self, PyBaseException, PyBaseExceptionRef},
+    exceptions,
     frame::{ExecutionResult, Frame, FrameRef},
     frozen,
     function::{FuncArgs, IntoFuncArgs},

wasm/lib/src/convert.rs

@@ -1,19 +1,16 @@
-use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, SyntaxError, Uint8Array};
-use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
-
-use rustpython_parser::error::ParseErrorType;
-use rustpython_vm::compile::{CompileError, CompileErrorType};
-use rustpython_vm::exceptions::PyBaseExceptionRef;
-use rustpython_vm::function::ArgBytesLike;
-use rustpython_vm::function::FuncArgs;
-use rustpython_vm::VirtualMachine;
-use rustpython_vm::{exceptions, py_serde};
-use rustpython_vm::{
-    ItemProtocol, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol,
-};
-
 use crate::js_module;
 use crate::vm_class::{stored_vm_from_wasm, WASMVirtualMachine};
+use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, SyntaxError, Uint8Array};
+use rustpython_parser::error::ParseErrorType;
+use rustpython_vm::{
+    builtins::PyBaseExceptionRef,
+    compile::{CompileError, CompileErrorType},
+    exceptions,
+    function::{ArgBytesLike, FuncArgs},
+    py_serde, ItemProtocol, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol,
+    VirtualMachine,
+};
+use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
 
 #[wasm_bindgen(inline_js = r"
 export class PyError extends Error {

wasm/lib/src/js_module.rs

@@ -6,8 +6,8 @@ use std::{cell, fmt, future};
 use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
 use wasm_bindgen_futures::{future_to_promise, JsFuture};
 
+use rustpython_vm::builtins::PyBaseExceptionRef;
 use rustpython_vm::builtins::{PyFloatRef, PyStrRef, PyTypeRef};
-use rustpython_vm::exceptions::PyBaseExceptionRef;
 use rustpython_vm::function::{OptionalArg, OptionalOption, PosArgs};
 use rustpython_vm::slots::{IteratorIterable, PyIter};
 use rustpython_vm::types::create_simple_type;