debug-friendly tweaks

Author: youknowone

stdlib/src/json/machinery.rs

@@ -105,10 +105,8 @@ pub struct DecodeError {
 }
 impl DecodeError {
     fn new(msg: impl Into<String>, pos: usize) -> Self {
-        Self {
-            msg: msg.into(),
-            pos,
-        }
+        let msg = msg.into();
+        Self { msg, pos }
     }
 }
 

vm/src/builtins/bytearray.rs

@@ -326,7 +326,8 @@ impl PyByteArray {
     fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult {
         let bytes = PyBytesInner::fromhex(string.as_str(), vm)?;
         let bytes = vm.ctx.new_bytes(bytes);
-        PyType::call(&cls, vec![bytes.into()].into(), vm)
+        let args = vec![bytes.into()].into();
+        PyType::call(&cls, args, vm)
     }
 
     #[pymethod]

vm/src/builtins/module.rs

@@ -80,7 +80,8 @@ impl Py<PyModule> {
     }
 
     pub fn get_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult {
-        self.getattr_inner(attr_name.as_pystr(&vm.ctx), vm)
+        let attr_name = attr_name.as_pystr(&vm.ctx);
+        self.getattr_inner(attr_name, vm)
     }
 
     pub fn set_attr<'a>(

vm/src/builtins/str.rs

@@ -310,8 +310,9 @@ impl PyStr {
         Self::new_str_unchecked(bytes, PyStrKind::Ascii)
     }
 
-    pub fn new_ref(s: impl Into<Self>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(s.into(), ctx.types.str_type.to_owned(), None)
+    pub fn new_ref(zelf: impl Into<Self>, ctx: &Context) -> PyRef<Self> {
+        let zelf = zelf.into();
+        PyRef::new_ref(zelf, ctx.types.str_type.to_owned(), None)
     }
 
     fn new_substr(&self, s: String) -> Self {

vm/src/builtins/type.rs

@@ -301,7 +301,8 @@ impl PyType {
         value: V,
         ctx: impl AsRef<Context>,
     ) {
-        let attr_name = ctx.as_ref().intern_str(attr_name);
+        let ctx = ctx.as_ref();
+        let attr_name = ctx.intern_str(attr_name);
         self.set_attr(attr_name, value.into())
     }
 

vm/src/function/protocol.rs

@@ -18,7 +18,8 @@ pub struct ArgCallable {
 impl ArgCallable {
     #[inline(always)]
     pub fn invoke(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
-        (self.call)(&self.obj, args.into_args(vm), vm)
+        let args = args.into_args(vm);
+        (self.call)(&self.obj, args, vm)
     }
 }
 

vm/src/object/core.rs

@@ -471,7 +471,6 @@ cfg_if::cfg_if! {
     }
 }
 
-#[derive(Debug)]
 #[repr(transparent)]
 pub struct PyObject(PyInner<Erased>);
 
@@ -522,7 +521,7 @@ impl PyObjectRef {
     #[inline(always)]
     pub fn downcast<T: PyObjectPayload>(self) -> Result<PyRef<T>, Self> {
         if self.payload_is::<T>() {
-            Ok(unsafe { PyRef::from_obj_unchecked(self) })
+            Ok(unsafe { self.downcast_unchecked() })
         } else {
             Err(self)
         }
@@ -539,6 +538,8 @@ impl PyObjectRef {
         }
     }
 
+    /// Force to downcast this reference to a subclass.
+    ///
     /// # Safety
     /// T must be the exact payload type
     #[inline(always)]
@@ -637,13 +638,22 @@ impl PyObject {
         self.0.typeid == TypeId::of::<T>()
     }
 
+    /// Force to return payload as T.
+    ///
+    /// # Safety
+    /// The actual payload type must be T.
+    #[inline(always)]
+    pub unsafe fn payload_unchecked<T: PyObjectPayload>(&self) -> &T {
+        // we cast to a PyInner<T> first because we don't know T's exact offset because of
+        // varying alignment, but once we get a PyInner<T> the compiler can get it for us
+        let inner = unsafe { &*(&self.0 as *const PyInner<Erased> as *const PyInner<T>) };
+        &inner.payload
+    }
+
     #[inline(always)]
     pub fn payload<T: PyObjectPayload>(&self) -> Option<&T> {
         if self.payload_is::<T>() {
-            // we cast to a PyInner<T> first because we don't know T's exact offset because of
-            // varying alignment, but once we get a PyInner<T> the compiler can get it for us
-            let inner = unsafe { &*(&self.0 as *const PyInner<Erased> as *const PyInner<T>) };
-            Some(&inner.payload)
+            Some(unsafe { self.payload_unchecked() })
         } else {
             None
         }
@@ -854,14 +864,20 @@ impl Drop for PyObjectRef {
     }
 }
 
-impl fmt::Debug for PyObjectRef {
+impl fmt::Debug for PyObject {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // SAFETY: the vtable contains functions that accept payload types that always match up
         // with the payload of the object
         unsafe { (self.0.vtable.debug)(self, f) }
     }
 }
 
+impl fmt::Debug for PyObjectRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_object().fmt(f)
+    }
+}
+
 #[repr(transparent)]
 pub struct Py<T: PyObjectPayload>(PyInner<T>);
 

vm/src/protocol/callable.rs

@@ -17,7 +17,8 @@ impl PyObject {
 
     /// PyObject_Call*Arg* series
     pub fn call(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
-        self.call_with_args(args.into_args(vm), vm)
+        let args = args.into_args(vm);
+        self.call_with_args(args, vm)
     }
 
     /// PyObject_Call
@@ -45,8 +46,9 @@ impl<'a> PyCallable<'a> {
     }
 
     pub fn invoke(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
+        let args = args.into_args(vm);
         vm.trace_event(TraceEvent::Call)?;
-        let result = (self.call)(self.obj, args.into_args(vm), vm);
+        let result = (self.call)(self.obj, args, vm);
         vm.trace_event(TraceEvent::Return)?;
         result
     }

vm/src/protocol/object.rs

@@ -133,7 +133,8 @@ impl PyObject {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         let attr_name = attr_name.as_pystr(&vm.ctx);
-        self.call_set_attr(vm, attr_name, PySetterValue::Assign(attr_value.into()))
+        let attr_value = attr_value.into();
+        self.call_set_attr(vm, attr_name, PySetterValue::Assign(attr_value))
     }
 
     // int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)

vm/src/stdlib/marshal.rs

@@ -149,7 +149,8 @@ mod decl {
             self.0.ctx.new_int(value).into()
         }
         fn make_tuple(&self, elements: impl Iterator<Item = Self::Value>) -> Self::Value {
-            self.0.ctx.new_tuple(elements.collect()).into()
+            let elements = elements.collect();
+            self.0.ctx.new_tuple(elements).into()
         }
         fn make_code(&self, code: CodeObject) -> Self::Value {
             self.0.ctx.new_code(code).into()