rustfmt

Author: ijl

src/decode.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use std::os::raw::c_char;
+use crate::typeref;
 use pyo3::prelude::*;
 use pyo3::types::*;
 use pyo3::IntoPyPointer;
@@ -9,7 +9,7 @@ use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::fmt;
 use std::marker::PhantomData;
-use crate::typeref;
+use std::os::raw::c_char;
 
 import_exception!(json, JSONDecodeError);
 
@@ -67,18 +67,14 @@ impl<'de, 'a> Visitor<'de> for JsonValue<'a> {
         E: de::Error,
     {
         match value {
-            true => {
-                unsafe {
-                    pyo3::ffi::Py_INCREF(typeref::TRUE);
-                    Ok(typeref::TRUE)
-                }
+            true => unsafe {
+                pyo3::ffi::Py_INCREF(typeref::TRUE);
+                Ok(typeref::TRUE)
+            },
+            false => unsafe {
+                pyo3::ffi::Py_INCREF(typeref::FALSE);
+                Ok(typeref::FALSE)
             },
-            false => {
-                unsafe {
-                    pyo3::ffi::Py_INCREF(typeref::FALSE);
-                    Ok(typeref::FALSE)
-                }
-            }
         }
     }
 
@@ -107,15 +103,24 @@ impl<'de, 'a> Visitor<'de> for JsonValue<'a> {
     where
         E: de::Error,
     {
-
-        Ok(unsafe { pyo3::ffi::PyUnicode_FromStringAndSize(value.as_ptr() as *const c_char, value.len() as pyo3::ffi::Py_ssize_t) })
+        Ok(unsafe {
+            pyo3::ffi::PyUnicode_FromStringAndSize(
+                value.as_ptr() as *const c_char,
+                value.len() as pyo3::ffi::Py_ssize_t,
+            )
+        })
     }
 
     fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
     where
         E: de::Error,
     {
-        Ok(unsafe { pyo3::ffi::PyUnicode_FromStringAndSize(value.as_ptr() as *const c_char, value.len() as pyo3::ffi::Py_ssize_t) })
+        Ok(unsafe {
+            pyo3::ffi::PyUnicode_FromStringAndSize(
+                value.as_ptr() as *const c_char,
+                value.len() as pyo3::ffi::Py_ssize_t,
+            )
+        })
     }
 
     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
@@ -139,11 +144,16 @@ impl<'de, 'a> Visitor<'de> for JsonValue<'a> {
     {
         let dict_ptr = PyDict::new(self.py).into_ptr();
         while let Some((key, value)) = map.next_entry_seed(PhantomData::<Cow<str>>, self)? {
-            let _ = unsafe { pyo3::ffi::PyDict_SetItem(
-                dict_ptr,
-                pyo3::ffi::PyUnicode_FromStringAndSize(key.as_ptr() as *const c_char, key.len() as pyo3::ffi::Py_ssize_t),
-                value,
-            ) };
+            let _ = unsafe {
+                pyo3::ffi::PyDict_SetItem(
+                    dict_ptr,
+                    pyo3::ffi::PyUnicode_FromStringAndSize(
+                        key.as_ptr() as *const c_char,
+                        key.len() as pyo3::ffi::Py_ssize_t,
+                    ),
+                    value,
+                )
+            };
         }
         Ok(dict_ptr)
     }

src/encode.rs

@@ -36,9 +36,7 @@ impl<'p, 'a> Serialize for SerializePyObject<'p, 'a> {
         } else if unsafe { obj_ptr == INT_PTR } {
             let val = unsafe { pyo3::ffi::PyLong_AsLong(self.obj.as_ptr()) };
             if unsafe { std::intrinsics::unlikely(val == -1 && PyErr::occurred(self.py)) } {
-                return Err(ser::Error::custom(
-                    "Integer exceeds 64-bit max"
-                ))
+                return Err(ser::Error::custom("Integer exceeds 64-bit max"));
             }
             serializer.serialize_i64(val)
         } else if unsafe { obj_ptr == BOOL_PTR } {
@@ -53,9 +51,7 @@ impl<'p, 'a> Serialize for SerializePyObject<'p, 'a> {
                 let mut map = serializer.serialize_map(Some(len))?;
                 for (key, value) in val.iter() {
                     if unsafe { std::intrinsics::unlikely(key.get_type_ptr() != STR_PTR) } {
-                        return Err(ser::Error::custom(
-                            "Dict key must be str"
-                        ));
+                        return Err(ser::Error::custom("Dict key must be str"));
                     }
                     map.serialize_entry(
                         unsafe {

src/lib.rs

@@ -38,13 +38,15 @@ pub fn loads(py: Python, obj: PyObject) -> PyResult<PyObject> {
     let obj_ptr = obj_ref.get_type_ptr();
     let val: Cow<str>;
     if unsafe { obj_ptr == typeref::STR_PTR } {
-        val = unsafe { Cow::Borrowed(std::str::from_utf8_unchecked(
-            <PyUnicode as PyTryFrom>::try_from_unchecked(obj_ref).as_bytes()
-        )) };
+        val = unsafe {
+            Cow::Borrowed(std::str::from_utf8_unchecked(
+                <PyUnicode as PyTryFrom>::try_from_unchecked(obj_ref).as_bytes(),
+            ))
+        };
     } else if unsafe { obj_ptr == typeref::BYTES_PTR } {
-        val = String::from_utf8_lossy(
-            unsafe { <PyBytes as PyTryFrom>::try_from_unchecked(obj_ref).as_bytes() }
-        );
+        val = String::from_utf8_lossy(unsafe {
+            <PyBytes as PyTryFrom>::try_from_unchecked(obj_ref).as_bytes()
+        });
     } else {
         return Err(pyo3::exceptions::TypeError::py_err(format!(
             "Input must be str or bytes, not: {}",