PyClass -> PyType

Author: youknowone

derive/src/pyclass.rs

@@ -73,15 +73,15 @@ pub(crate) fn impl_pyimpl(
 
                     fn impl_extend_class(
                         ctx: &::rustpython_vm::pyobject::PyContext,
-                        class: &::rustpython_vm::obj::objtype::PyClassRef,
+                        class: &::rustpython_vm::obj::objtype::PyTypeRef,
                     ) {
                         #getset_impl
                         #extend_impl
                         #with_impl
                         #(#class_extensions)*
                     }
 
-                    fn extend_slots(slots: &mut ::rustpython_vm::slots::PyClassSlots) {
+                    fn extend_slots(slots: &mut ::rustpython_vm::slots::PyTypeSlots) {
                         #with_slots
                         #slots_impl
                     }
@@ -100,15 +100,15 @@ pub(crate) fn impl_pyimpl(
                 parse_quote! {
                     fn __extend_py_class(
                         ctx: &::rustpython_vm::pyobject::PyContext,
-                        class: &::rustpython_vm::obj::objtype::PyClassRef,
+                        class: &::rustpython_vm::obj::objtype::PyTypeRef,
                     ) {
                         #getset_impl
                         #extend_impl
                         #(#class_extensions)*
                     }
                 },
                 parse_quote! {
-                    fn __extend_slots(slots: &mut ::rustpython_vm::slots::PyClassSlots) {
+                    fn __extend_slots(slots: &mut ::rustpython_vm::slots::PyTypeSlots) {
                         #slots_impl
                     }
                 },
@@ -162,7 +162,7 @@ fn generate_class_def(
 
     let base_class = if is_pystruct {
         quote! {
-            fn base_class(ctx: &::rustpython_vm::pyobject::PyContext) -> ::rustpython_vm::obj::objtype::PyClassRef {
+            fn base_class(ctx: &::rustpython_vm::pyobject::PyContext) -> ::rustpython_vm::obj::objtype::PyTypeRef {
                 ctx.types.tuple_type.clone()
             }
         }

vm/src/builtins.rs

@@ -30,7 +30,7 @@ mod decl {
     use crate::obj::objlist::{PyList, SortOptions};
     use crate::obj::objsequence;
     use crate::obj::objstr::{PyStr, PyStrRef};
-    use crate::obj::objtype::{self, PyClassRef};
+    use crate::obj::objtype::{self, PyTypeRef};
     use crate::pyobject::{
         BorrowValue, Either, IdProtocol, ItemProtocol, PyCallable, PyIterable, PyObjectRef,
         PyResult, PyValue, TryFromObject, TypeProtocol,
@@ -400,7 +400,7 @@ mod decl {
     pub fn isinstance(obj: PyObjectRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         single_or_tuple_any(
             typ,
-            &|cls: &PyClassRef| vm.isinstance(&obj, cls),
+            &|cls: &PyTypeRef| vm.isinstance(&obj, cls),
             &|o| {
                 format!(
                     "isinstance() arg 2 must be a type or tuple of types, not {}",
@@ -412,10 +412,10 @@ mod decl {
     }
 
     #[pyfunction]
-    fn issubclass(subclass: PyClassRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+    fn issubclass(subclass: PyTypeRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         single_or_tuple_any(
             typ,
-            &|cls: &PyClassRef| vm.issubclass(&subclass, cls),
+            &|cls: &PyTypeRef| vm.issubclass(&subclass, cls),
             &|o| {
                 format!(
                     "issubclass() arg 2 must be a class or tuple of classes, not {}",
@@ -803,7 +803,7 @@ mod decl {
     pub fn __build_class__(
         function: PyFunctionRef,
         qualified_name: PyStrRef,
-        bases: Args<PyClassRef>,
+        bases: Args<PyTypeRef>,
         mut kwargs: KwArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
@@ -815,7 +815,7 @@ mod decl {
         let name_obj = vm.ctx.new_str(name);
 
         let mut metaclass = if let Some(metaclass) = kwargs.pop_kwarg("metaclass") {
-            PyClassRef::try_from_object(vm, metaclass)?
+            PyTypeRef::try_from_object(vm, metaclass)?
         } else {
             vm.ctx.types.type_type.clone()
         };

vm/src/exceptions.rs

@@ -4,7 +4,7 @@ use crate::obj::objsingletons::{PyNone, PyNoneRef};
 use crate::obj::objstr::{PyStr, PyStrRef};
 use crate::obj::objtraceback::PyTracebackRef;
 use crate::obj::objtuple::{PyTuple, PyTupleRef};
-use crate::obj::objtype::{self, PyClass, PyClassRef};
+use crate::obj::objtype::{self, PyType, PyTypeRef};
 use crate::py_io::{self, Write};
 use crate::pyobject::{
     BorrowValue, IntoPyObject, PyClassDef, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef,
@@ -44,7 +44,7 @@ pub trait IntoPyException {
 }
 
 impl PyValue for PyBaseException {
-    fn class(vm: &VirtualMachine) -> PyClassRef {
+    fn class(vm: &VirtualMachine) -> PyTypeRef {
         vm.ctx.exceptions.base_exception_type.clone()
     }
 }
@@ -62,7 +62,7 @@ impl PyBaseException {
     }
 
     #[pyslot]
-    fn tp_new(cls: PyClassRef, args: PyFuncArgs, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+    fn tp_new(cls: PyTypeRef, args: PyFuncArgs, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         PyBaseException::new(args.args, vm).into_ref_with_type(vm, cls)
     }
 
@@ -295,13 +295,13 @@ fn exception_args_as_string(
 
 #[derive(Clone)]
 pub enum ExceptionCtor {
-    Class(PyClassRef),
+    Class(PyTypeRef),
     Instance(PyBaseExceptionRef),
 }
 
 impl TryFromObject for ExceptionCtor {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        obj.downcast::<PyClass>()
+        obj.downcast::<PyType>()
             .and_then(|cls| {
                 if objtype::issubclass(&cls, &vm.ctx.exceptions.base_exception_type) {
                     Ok(Self::Class(cls))
@@ -320,7 +320,7 @@ impl TryFromObject for ExceptionCtor {
 }
 
 pub fn invoke(
-    cls: PyClassRef,
+    cls: PyTypeRef,
     args: Vec<PyObjectRef>,
     vm: &VirtualMachine,
 ) -> PyResult<PyBaseExceptionRef> {
@@ -392,80 +392,80 @@ pub fn normalize(
 
 #[derive(Debug)]
 pub struct ExceptionZoo {
-    pub base_exception_type: PyClassRef,
-    pub system_exit: PyClassRef,
-    pub keyboard_interrupt: PyClassRef,
-    pub generator_exit: PyClassRef,
-    pub exception_type: PyClassRef,
-    pub stop_iteration: PyClassRef,
-    pub stop_async_iteration: PyClassRef,
-    pub arithmetic_error: PyClassRef,
-    pub floating_point_error: PyClassRef,
-    pub overflow_error: PyClassRef,
-    pub zero_division_error: PyClassRef,
-    pub assertion_error: PyClassRef,
-    pub attribute_error: PyClassRef,
-    pub buffer_error: PyClassRef,
-    pub eof_error: PyClassRef,
-    pub import_error: PyClassRef,
-    pub module_not_found_error: PyClassRef,
-    pub lookup_error: PyClassRef,
-    pub index_error: PyClassRef,
-    pub key_error: PyClassRef,
-    pub memory_error: PyClassRef,
-    pub name_error: PyClassRef,
-    pub unbound_local_error: PyClassRef,
-    pub os_error: PyClassRef,
-    pub blocking_io_error: PyClassRef,
-    pub child_process_error: PyClassRef,
-    pub connection_error: PyClassRef,
-    pub broken_pipe_error: PyClassRef,
-    pub connection_aborted_error: PyClassRef,
-    pub connection_refused_error: PyClassRef,
-    pub connection_reset_error: PyClassRef,
-    pub file_exists_error: PyClassRef,
-    pub file_not_found_error: PyClassRef,
-    pub interrupted_error: PyClassRef,
-    pub is_a_directory_error: PyClassRef,
-    pub not_a_directory_error: PyClassRef,
-    pub permission_error: PyClassRef,
-    pub process_lookup_error: PyClassRef,
-    pub timeout_error: PyClassRef,
-    pub reference_error: PyClassRef,
-    pub runtime_error: PyClassRef,
-    pub not_implemented_error: PyClassRef,
-    pub recursion_error: PyClassRef,
-    pub syntax_error: PyClassRef,
-    pub target_scope_error: PyClassRef,
-    pub indentation_error: PyClassRef,
-    pub tab_error: PyClassRef,
-    pub system_error: PyClassRef,
-    pub type_error: PyClassRef,
-    pub value_error: PyClassRef,
-    pub unicode_error: PyClassRef,
-    pub unicode_decode_error: PyClassRef,
-    pub unicode_encode_error: PyClassRef,
-    pub unicode_translate_error: PyClassRef,
+    pub base_exception_type: PyTypeRef,
+    pub system_exit: PyTypeRef,
+    pub keyboard_interrupt: PyTypeRef,
+    pub generator_exit: PyTypeRef,
+    pub exception_type: PyTypeRef,
+    pub stop_iteration: PyTypeRef,
+    pub stop_async_iteration: PyTypeRef,
+    pub arithmetic_error: PyTypeRef,
+    pub floating_point_error: PyTypeRef,
+    pub overflow_error: PyTypeRef,
+    pub zero_division_error: PyTypeRef,
+    pub assertion_error: PyTypeRef,
+    pub attribute_error: PyTypeRef,
+    pub buffer_error: PyTypeRef,
+    pub eof_error: PyTypeRef,
+    pub import_error: PyTypeRef,
+    pub module_not_found_error: PyTypeRef,
+    pub lookup_error: PyTypeRef,
+    pub index_error: PyTypeRef,
+    pub key_error: PyTypeRef,
+    pub memory_error: PyTypeRef,
+    pub name_error: PyTypeRef,
+    pub unbound_local_error: PyTypeRef,
+    pub os_error: PyTypeRef,
+    pub blocking_io_error: PyTypeRef,
+    pub child_process_error: PyTypeRef,
+    pub connection_error: PyTypeRef,
+    pub broken_pipe_error: PyTypeRef,
+    pub connection_aborted_error: PyTypeRef,
+    pub connection_refused_error: PyTypeRef,
+    pub connection_reset_error: PyTypeRef,
+    pub file_exists_error: PyTypeRef,
+    pub file_not_found_error: PyTypeRef,
+    pub interrupted_error: PyTypeRef,
+    pub is_a_directory_error: PyTypeRef,
+    pub not_a_directory_error: PyTypeRef,
+    pub permission_error: PyTypeRef,
+    pub process_lookup_error: PyTypeRef,
+    pub timeout_error: PyTypeRef,
+    pub reference_error: PyTypeRef,
+    pub runtime_error: PyTypeRef,
+    pub not_implemented_error: PyTypeRef,
+    pub recursion_error: PyTypeRef,
+    pub syntax_error: PyTypeRef,
+    pub target_scope_error: PyTypeRef,
+    pub indentation_error: PyTypeRef,
+    pub tab_error: PyTypeRef,
+    pub system_error: PyTypeRef,
+    pub type_error: PyTypeRef,
+    pub value_error: PyTypeRef,
+    pub unicode_error: PyTypeRef,
+    pub unicode_decode_error: PyTypeRef,
+    pub unicode_encode_error: PyTypeRef,
+    pub unicode_translate_error: PyTypeRef,
 
     #[cfg(feature = "jit")]
-    pub jit_error: PyClassRef,
-
-    pub warning: PyClassRef,
-    pub deprecation_warning: PyClassRef,
-    pub pending_deprecation_warning: PyClassRef,
-    pub runtime_warning: PyClassRef,
-    pub syntax_warning: PyClassRef,
-    pub user_warning: PyClassRef,
-    pub future_warning: PyClassRef,
-    pub import_warning: PyClassRef,
-    pub unicode_warning: PyClassRef,
-    pub bytes_warning: PyClassRef,
-    pub resource_warning: PyClassRef,
+    pub jit_error: PyTypeRef,
+
+    pub warning: PyTypeRef,
+    pub deprecation_warning: PyTypeRef,
+    pub pending_deprecation_warning: PyTypeRef,
+    pub runtime_warning: PyTypeRef,
+    pub syntax_warning: PyTypeRef,
+    pub user_warning: PyTypeRef,
+    pub future_warning: PyTypeRef,
+    pub import_warning: PyTypeRef,
+    pub unicode_warning: PyTypeRef,
+    pub bytes_warning: PyTypeRef,
+    pub resource_warning: PyTypeRef,
 }
 
 impl ExceptionZoo {
-    pub fn new(type_type: &PyClassRef, object_type: &PyClassRef) -> Self {
-        let create_exception_type = |name: &str, base: &PyClassRef| {
+    pub fn new(type_type: &PyTypeRef, object_type: &PyTypeRef) -> Self {
+        let create_exception_type = |name: &str, base: &PyTypeRef| {
             create_type_with_slots(name, type_type, base.clone(), PyBaseException::make_slots())
         };
         // Sorted By Hierarchy then alphabetized.

vm/src/frame.rs

@@ -22,7 +22,7 @@ use crate::obj::objslice::PySlice;
 use crate::obj::objstr::{self, PyStr, PyStrRef};
 use crate::obj::objtraceback::PyTraceback;
 use crate::obj::objtuple::PyTuple;
-use crate::obj::objtype::{self, PyClassRef};
+use crate::obj::objtype::{self, PyTypeRef};
 use crate::pyobject::{
     BorrowValue, IdProtocol, ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
     TypeProtocol,
@@ -100,7 +100,7 @@ pub struct Frame {
 }
 
 impl PyValue for Frame {
-    fn class(vm: &VirtualMachine) -> PyClassRef {
+    fn class(vm: &VirtualMachine) -> PyTypeRef {
         vm.ctx.types.frame_type.clone()
     }
 }

vm/src/function.rs

@@ -8,7 +8,7 @@ use result_like::impl_option_like;
 
 use crate::exceptions::PyBaseExceptionRef;
 use crate::obj::objtuple::PyTupleRef;
-use crate::obj::objtype::{isinstance, PyClassRef};
+use crate::obj::objtype::{isinstance, PyTypeRef};
 use crate::pyobject::{
     BorrowValue, IntoPyResult, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue,
     TryFromObject, TypeProtocol,
@@ -121,7 +121,7 @@ impl PyFuncArgs {
     pub fn get_optional_kwarg_with_type(
         &self,
         key: &str,
-        ty: PyClassRef,
+        ty: PyTypeRef,
         vm: &VirtualMachine,
     ) -> PyResult<Option<PyObjectRef>> {
         match self.get_optional_kwarg(key) {

vm/src/macros.rs

@@ -39,7 +39,7 @@ macro_rules! py_class {
     ( $ctx:expr, $class_name:expr, $class_base:expr, $flags:expr, { $($name:tt => $value:expr),* $(,)* }) => {
         {
             #[allow(unused_mut)]
-            let mut slots = $crate::slots::PyClassSlots::from_flags($crate::slots::PyTpFlags::DEFAULT | $flags);
+            let mut slots = $crate::slots::PyTypeSlots::from_flags($crate::slots::PyTpFlags::DEFAULT | $flags);
             $($crate::py_class!(@extract_slots($ctx, &mut slots, $name, $value));)*
             let py_class = $ctx.new_class($class_name, $class_base.clone(), slots);
             $($crate::py_class!(@extract_attrs($ctx, &py_class, $name, $value));)*

vm/src/obj/objasyncgenerator.rs

@@ -1,6 +1,6 @@
 use super::objcode::PyCodeRef;
 use super::objcoroinner::{Coro, Variant};
-use super::objtype::{self, PyClassRef};
+use super::objtype::{self, PyTypeRef};
 use crate::exceptions::PyBaseExceptionRef;
 use crate::frame::FrameRef;
 use crate::function::OptionalArg;
@@ -18,7 +18,7 @@ pub struct PyAsyncGen {
 pub type PyAsyncGenRef = PyRef<PyAsyncGen>;
 
 impl PyValue for PyAsyncGen {
-    fn class(vm: &VirtualMachine) -> PyClassRef {
+    fn class(vm: &VirtualMachine) -> PyTypeRef {
         vm.ctx.types.async_generator.clone()
     }
 }
@@ -116,7 +116,7 @@ impl PyAsyncGen {
 #[derive(Debug)]
 pub(crate) struct PyAsyncGenWrappedValue(pub PyObjectRef);
 impl PyValue for PyAsyncGenWrappedValue {
-    fn class(vm: &VirtualMachine) -> PyClassRef {
+    fn class(vm: &VirtualMachine) -> PyTypeRef {
         vm.ctx.types.async_generator_wrapped_value.clone()
     }
 }
@@ -165,7 +165,7 @@ pub(crate) struct PyAsyncGenASend {
 }
 
 impl PyValue for PyAsyncGenASend {
-    fn class(vm: &VirtualMachine) -> PyClassRef {
+    fn class(vm: &VirtualMachine) -> PyTypeRef {
         vm.ctx.types.async_generator_asend.clone()
     }
 }
@@ -261,7 +261,7 @@ pub(crate) struct PyAsyncGenAThrow {
 }
 
 impl PyValue for PyAsyncGenAThrow {
-    fn class(vm: &VirtualMachine) -> PyClassRef {
+    fn class(vm: &VirtualMachine) -> PyTypeRef {
         vm.ctx.types.async_generator_athrow.clone()
     }
 }