style: cargo fmt

discord9 · discord9 · commit 8c0ba39492d7 · 2022-10-11T16:37:51.000+08:00
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
@@ -353,8 +353,8 @@ impl ExecutingFrame<'_> {
             let result = self.execute_instruction(instr, vm);
             if matches!(instr, &bytecode::Instruction::ReturnValue) {
                 // only do gc if after certain instruction(to be decided), so to avoid strange bugs?
-                // it seems ReturnValue is safe enough& frequent enough to do gc() after execute it?
-                //  | &bytecode::Instruction::StoreLocal(..)
+                // it seems ReturnValue is safe enough & frequent enough to do gc() after execute it?
+                // &bytecode::Instruction::ReturnValue | &bytecode::Instruction::StoreLocal(..)
                 #[cfg(feature = "gc")]
                 {
                     #[cfg(feature = "threading")]
diff --git a/vm/src/object/core.rs b/vm/src/object/core.rs
@@ -252,9 +252,7 @@ unsafe impl GcTrace for PyObject {
 impl From<&PyInner<Erased>> for &PyObject {
     fn from(inner: &PyInner<Erased>) -> Self {
         // Safety: PyObject is #[repr(transparent)], so cast is safe
-        unsafe {
-            NonNull::from(inner).cast::<PyObject>().as_ref()
-        }
+        unsafe { NonNull::from(inner).cast::<PyObject>().as_ref() }
     }
 }
 
@@ -647,9 +645,9 @@ impl Drop for PyWeak {
     fn drop(&mut self) {
         // we do NOT have actual exclusive access!
         // no clue if doing this actually reduces chance of UB
-        // let me: &Self = self;
+        let me: &Self = self;
         // deallocate&drop is handle by garbage collector, don't do it here.
-        // me.drop_inner();
+        me.drop_inner();
     }
 }
 
@@ -877,7 +875,6 @@ impl PyObjectRef {
 }
 
 impl PyObject {
-
     #[inline(always)]
     fn weak_ref_list(&self) -> Option<&WeakRefList> {
         Some(&self.0.weak_list)
@@ -1183,11 +1180,11 @@ impl PyObject {
                     ($ID: tt, $($TY: ty),*$(,)?) => {
                         $(
                             if TypeId::of::<$TY>()==$ID{
-                                std::stringify!($TY)
+                                String::from(std::stringify!($TY))
                             }
                         )else*
                         else{
-                            "Unknown type"
+                            format!("Unknown type, id={:?}", $ID)
                         }
                     };
                 }
diff --git a/vm/src/object/gc/collector_sync.rs b/vm/src/object/gc/collector_sync.rs
@@ -1,7 +1,7 @@
 use std::time::Instant;
 use std::{fmt, ops::Deref, ptr::NonNull};
 
-use crate::object::gc::{deadlock_handler, Color, GcObjPtr, GcStatus, GcTrace, GcObj, GcObjRef};
+use crate::object::gc::{deadlock_handler, Color, GcObj, GcObjPtr, GcObjRef, GcStatus, GcTrace};
 use crate::PyObject;
 
 use rustpython_common::{
@@ -120,7 +120,6 @@ impl std::fmt::Debug for CcSync {
 
 // TODO: change to use PyInner<Erased> directly
 
-
 impl CcSync {
     thread_local! {
         /// assume any drop() impl doesn't create new thread, so gc only work in this one thread.
diff --git a/vm/src/object/gc/mod.rs b/vm/src/object/gc/mod.rs
@@ -4,11 +4,11 @@ mod collector_sync;
 mod header;
 mod trace;
 
+use crate::PyObject;
 pub use collector_sync::GcResult;
 pub(crate) use collector_sync::{CcSync, GLOBAL_COLLECTOR};
 pub(crate) use header::{Color, GcHeader};
 pub(crate) use trace::{GcObjPtr, GcStatus, GcTrace, TracerFn};
-use crate::PyObject;
 type GcObj = PyObject;
 type GcObjRef<'a> = &'a GcObj;
 

Original file line number	Diff line number	Diff line change
`@@ -252,9 +252,7 @@ unsafe impl GcTrace for PyObject {`
`252`	`252`	`impl From<&PyInner<Erased>> for &PyObject {`
`253`	`253`	`fn from(inner: &PyInner<Erased>) -> Self {`
`254`	`254`	`// Safety: PyObject is #[repr(transparent)], so cast is safe`
`255`		`- unsafe {`
`256`		`- NonNull::from(inner).cast::<PyObject>().as_ref()`
`257`		`- }`
	`255`	`+ unsafe { NonNull::from(inner).cast::<PyObject>().as_ref() }`
`258`	`256`	`}`
`259`	`257`	`}`
`260`	`258`
`@@ -647,9 +645,9 @@ impl Drop for PyWeak {`
`647`	`645`	`fn drop(&mut self) {`
`648`	`646`	`// we do NOT have actual exclusive access!`
`649`	`647`	`// no clue if doing this actually reduces chance of UB`
`650`		`- // let me: &Self = self;`
	`648`	`+ let me: &Self = self;`
`651`	`649`	`// deallocate&drop is handle by garbage collector, don't do it here.`
`652`		`- // me.drop_inner();`
	`650`	`+ me.drop_inner();`
`653`	`651`	`}`
`654`	`652`	`}`
`655`	`653`
`@@ -877,7 +875,6 @@ impl PyObjectRef {`
`877`	`875`	`}`
`878`	`876`
`879`	`877`	`impl PyObject {`
`880`		`-`
`881`	`878`	`#[inline(always)]`
`882`	`879`	`fn weak_ref_list(&self) -> Option<&WeakRefList> {`
`883`	`880`	`Some(&self.0.weak_list)`
`@@ -1183,11 +1180,11 @@ impl PyObject {`
`1183`	`1180`	`($ID: tt, $($TY: ty),*$(,)?) => {`
`1184`	`1181`	`$(`
`1185`	`1182`	`if TypeId::of::<$TY>()==$ID{`
`1186`		`- std::stringify!($TY)`
	`1183`	`+ String::from(std::stringify!($TY))`
`1187`	`1184`	`}`
`1188`	`1185`	`)else*`
`1189`	`1186`	`else{`
`1190`		`- "Unknown type"`
	`1187`	`+ format!("Unknown type, id={:?}", $ID)`
`1191`	`1188`	`}`
`1192`	`1189`	`};`
`1193`	`1190`	`}`