Impl std::ops::Deref for ArgIntoBool

Author: youknowone

vm/src/buffer.rs

@@ -566,7 +566,7 @@ impl Packable for *mut raw::c_void {
 
 impl Packable for bool {
     fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-        let v = ArgIntoBool::try_from_object(vm, arg)?.to_bool() as u8;
+        let v = *ArgIntoBool::try_from_object(vm, arg)? as u8;
         v.pack_int::<E>(data);
         Ok(())
     }

vm/src/builtins/int.rs

@@ -606,7 +606,7 @@ impl PyInt {
         args: IntFromByteArgs,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<Self>> {
-        let signed = args.signed.map_or(false, |s| s.to_bool());
+        let signed = args.signed.map_or(false, Into::into);
         let value = match (args.byteorder.as_str(), signed) {
             ("big", true) => BigInt::from_signed_bytes_be(&args.bytes.elements),
             ("big", false) => BigInt::from_bytes_be(Sign::Plus, &args.bytes.elements),
@@ -623,12 +623,7 @@ impl PyInt {
 
     #[pymethod]
     fn to_bytes(&self, args: IntToByteArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
-        let signed = if let OptionalArg::Present(signed) = args.signed {
-            signed.to_bool()
-        } else {
-            false
-        };
-
+        let signed = args.signed.map_or(false, Into::into);
         let byte_len = args.length.try_to_primitive(vm)?;
 
         let value = self.as_bigint();

vm/src/builtins/zip.rs

@@ -61,7 +61,7 @@ impl PyZip {
     #[pymethod(magic)]
     fn setstate(zelf: PyRef<Self>, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-            zelf.strict.store(obj.to_bool(), atomic::Ordering::Release);
+            zelf.strict.store(obj.into(), atomic::Ordering::Release);
         }
         Ok(())
     }

vm/src/function/number.rs

@@ -1,5 +1,6 @@
 use crate::{AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine};
 use num_complex::Complex64;
+use std::ops::Deref;
 
 /// A Python complex-like object.
 ///
@@ -10,12 +11,20 @@ use num_complex::Complex64;
 /// method, this method will first be called to convert the object into a float.
 /// If `__complex__()` is not defined then it falls back to `__float__()`. If
 /// `__float__()` is not defined it falls back to `__index__()`.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, PartialEq)]
 #[repr(transparent)]
 pub struct ArgIntoComplex {
     value: Complex64,
 }
 
+impl Deref for ArgIntoComplex {
+    type Target = Complex64;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
 impl ArgIntoComplex {
     pub fn to_complex(self) -> Complex64 {
         self.value
@@ -41,7 +50,7 @@ impl TryFromObject for ArgIntoComplex {
 /// If the object is not a Python floating point object but has a `__float__()`
 /// method, this method will first be called to convert the object into a float.
 /// If `__float__()` is not defined then it falls back to `__index__()`.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, PartialEq)]
 #[repr(transparent)]
 pub struct ArgIntoFloat {
     value: f64,
@@ -79,23 +88,32 @@ impl TryFromObject for ArgIntoFloat {
 /// By default an object is considered true unless its class defines either a
 /// `__bool__()` method that returns False or a `__len__()` method that returns
 /// zero, when called with the object.
-#[derive(Debug, Default, Copy, Clone, PartialEq)]
+#[derive(Debug, Default, PartialEq)]
 pub struct ArgIntoBool {
     value: bool,
 }
 
 impl ArgIntoBool {
-    pub const TRUE: ArgIntoBool = ArgIntoBool { value: true };
-    pub const FALSE: ArgIntoBool = ArgIntoBool { value: false };
+    pub const TRUE: Self = Self { value: true };
+    pub const FALSE: Self = Self { value: false };
+}
 
-    pub fn to_bool(self) -> bool {
-        self.value
+impl From<ArgIntoBool> for bool {
+    fn from(arg: ArgIntoBool) -> Self {
+        arg.value
+    }
+}
+
+impl Deref for ArgIntoBool {
+    type Target = bool;
+    fn deref(&self) -> &Self::Target {
+        &self.value
     }
 }
 
 impl TryFromObject for ArgIntoBool {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        Ok(ArgIntoBool {
+        Ok(Self {
             value: obj.try_to_bool(vm)?,
         })
     }

vm/src/stdlib/builtins.rs

@@ -47,7 +47,7 @@ mod builtins {
     #[pyfunction]
     fn all(iterable: ArgIterable<ArgIntoBool>, vm: &VirtualMachine) -> PyResult<bool> {
         for item in iterable.iter(vm)? {
-            if !item?.to_bool() {
+            if !*item? {
                 return Ok(false);
             }
         }
@@ -57,7 +57,7 @@ mod builtins {
     #[pyfunction]
     fn any(iterable: ArgIterable<ArgIntoBool>, vm: &VirtualMachine) -> PyResult<bool> {
         for item in iterable.iter(vm)? {
-            if item?.to_bool() {
+            if *item? {
                 return Ok(true);
             }
         }
@@ -671,7 +671,7 @@ mod builtins {
             .unwrap_or_else(|| PyStr::from("\n").into_ref(vm));
         write(end)?;
 
-        if options.flush.to_bool() {
+        if *options.flush {
             vm.call_method(&file, "flush", ())?;
         }