edition 2024

ijl · ijl · commit c8c1a17dca84 · 2025-10-24T13:37:00.000Z
diff --git a/Cargo.toml b/Cargo.toml
@@ -2,8 +2,8 @@
 name = "orjson"
 version = "3.11.3"
 authors = ["ijl <ijl@mailbox.org>"]
-edition = "2021"
-resolver = "2"
+edition = "2024"
+resolver = "3"
 rust-version = "1.85"
 license = "Apache-2.0 OR MIT"
 keywords = ["fast", "json", "dataclass", "dataclasses", "datetime", "rfc", "8259", "3339"]
diff --git a/src/deserialize/backend/json.rs b/src/deserialize/backend/json.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use crate::deserialize::pyobject::*;
 use crate::deserialize::DeserializeError;
+use crate::deserialize::pyobject::*;
 use crate::str::PyStr;
 use core::ptr::NonNull;
 use serde::de::{self, DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor};
diff --git a/src/deserialize/backend/yyjson.rs b/src/deserialize/backend/yyjson.rs
@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+use crate::deserialize::DeserializeError;
 use crate::deserialize::pyobject::{
     get_unicode_key, parse_f64, parse_false, parse_i64, parse_none, parse_true, parse_u64,
 };
-use crate::deserialize::DeserializeError;
 use crate::ffi::yyjson::{
-    yyjson_alc_pool_init, yyjson_doc, yyjson_read_err, yyjson_read_opts, yyjson_val,
-    YYJSON_READ_SUCCESS,
+    YYJSON_READ_SUCCESS, yyjson_alc_pool_init, yyjson_doc, yyjson_read_err, yyjson_read_opts,
+    yyjson_val,
 };
 use crate::str::PyStr;
 use crate::util::usize_to_isize;
 use core::ffi::c_char;
-use core::ptr::{null, null_mut, NonNull};
+use core::ptr::{NonNull, null, null_mut};
 use std::borrow::Cow;
 
 const YYJSON_TAG_BIT: u8 = 8;
diff --git a/src/deserialize/deserializer.rs b/src/deserialize/deserializer.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use crate::deserialize::utf8::read_input_to_buf;
 use crate::deserialize::DeserializeError;
+use crate::deserialize::utf8::read_input_to_buf;
 use crate::typeref::EMPTY_UNICODE;
 use core::ptr::NonNull;
 
diff --git a/src/deserialize/mod.rs b/src/deserialize/mod.rs
@@ -9,6 +9,6 @@ mod pyobject;
 mod utf8;
 
 #[cfg(not(Py_GIL_DISABLED))]
-pub(crate) use cache::{KeyMap, KEY_MAP};
+pub(crate) use cache::{KEY_MAP, KeyMap};
 pub(crate) use deserializer::deserialize;
 pub(crate) use error::DeserializeError;
diff --git a/src/deserialize/pyobject.rs b/src/deserialize/pyobject.rs
@@ -37,11 +37,7 @@ pub(crate) fn get_unicode_key(key_str: &str) -> PyStr {
 #[allow(dead_code)]
 #[inline(always)]
 pub(crate) fn parse_bool(val: bool) -> NonNull<pyo3_ffi::PyObject> {
-    if val {
-        parse_true()
-    } else {
-        parse_false()
-    }
+    if val { parse_true() } else { parse_false() }
 }
 
 #[inline(always)]
diff --git a/src/deserialize/utf8.rs b/src/deserialize/utf8.rs
@@ -4,8 +4,8 @@ use crate::deserialize::DeserializeError;
 use crate::ffi::{PyBytes_AS_STRING, PyBytes_GET_SIZE, PyMemoryView_GET_BUFFER};
 use crate::str::PyStr;
 use crate::typeref::{BYTEARRAY_TYPE, BYTES_TYPE, MEMORYVIEW_TYPE, STR_TYPE};
-use crate::util::isize_to_usize;
 use crate::util::INVALID_STR;
+use crate::util::isize_to_usize;
 use core::ffi::c_char;
 use std::borrow::Cow;
 
diff --git a/src/ffi/buffer.rs b/src/ffi/buffer.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 use core::ffi::c_int;
-use pyo3_ffi::{PyObject, PyVarObject, Py_buffer, Py_hash_t, Py_ssize_t};
+use pyo3_ffi::{Py_buffer, Py_hash_t, Py_ssize_t, PyObject, PyVarObject};
 
 #[repr(C)]
 pub(crate) struct _PyManagedBufferObject {
diff --git a/src/ffi/bytes.rs b/src/ffi/bytes.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 use core::ffi::c_char;
-use pyo3_ffi::{PyBytesObject, PyObject, Py_ssize_t};
+use pyo3_ffi::{Py_ssize_t, PyBytesObject, PyObject};
 
 use super::compat::Py_SIZE;
 
diff --git a/src/ffi/fragment.rs b/src/ffi/fragment.rs
@@ -4,8 +4,8 @@ use core::ffi::c_char;
 
 use core::ptr::null_mut;
 use pyo3_ffi::{
-    PyErr_SetObject, PyExc_TypeError, PyObject, PyTypeObject, PyType_Ready, PyType_Type,
-    PyUnicode_FromStringAndSize, PyVarObject, Py_DECREF, Py_INCREF, Py_SIZE, Py_TPFLAGS_DEFAULT,
+    Py_DECREF, Py_INCREF, Py_SIZE, Py_TPFLAGS_DEFAULT, PyErr_SetObject, PyExc_TypeError, PyObject,
+    PyType_Ready, PyType_Type, PyTypeObject, PyUnicode_FromStringAndSize, PyVarObject,
 };
 
 #[cfg(Py_GIL_DISABLED)]
diff --git a/src/ffi/mod.rs b/src/ffi/mod.rs
@@ -14,7 +14,7 @@ pub(crate) use buffer::*;
 pub(crate) use bytes::*;
 pub(crate) use compat::*;
 
-pub(crate) use fragment::{orjson_fragmenttype_new, Fragment};
+pub(crate) use fragment::{Fragment, orjson_fragmenttype_new};
 pub(crate) use long::pylong_is_unsigned;
 #[cfg(feature = "inline_int")]
 pub(crate) use long::{pylong_fits_in_i32, pylong_get_inline_value, pylong_is_zero};
diff --git a/src/lib.rs b/src/lib.rs
@@ -26,6 +26,7 @@
 #![allow(clippy::host_endian_bytes)]
 #![allow(clippy::if_not_else)]
 #![allow(clippy::implicit_return)]
+#![allow(clippy::incompatible_msrv)] // MSRV 1.89
 #![allow(clippy::inline_always)]
 #![allow(clippy::let_underscore_untyped)]
 #![allow(clippy::missing_assert_message)]
@@ -83,16 +84,16 @@ mod typeref;
 
 use core::ffi::{c_char, c_int, c_void};
 use pyo3_ffi::{
-    PyCFunction_NewEx, PyErr_SetObject, PyLong_AsLong, PyLong_FromLongLong, PyMethodDef,
-    PyMethodDefPointer, PyModuleDef, PyModuleDef_HEAD_INIT, PyModuleDef_Slot, PyObject,
-    PyTuple_New, PyUnicode_FromStringAndSize, PyUnicode_InternFromString, PyVectorcall_NARGS,
-    Py_DECREF, Py_SIZE, Py_ssize_t, METH_KEYWORDS, METH_O,
+    METH_KEYWORDS, METH_O, Py_DECREF, Py_SIZE, Py_ssize_t, PyCFunction_NewEx, PyErr_SetObject,
+    PyLong_AsLong, PyLong_FromLongLong, PyMethodDef, PyMethodDefPointer, PyModuleDef,
+    PyModuleDef_HEAD_INIT, PyModuleDef_Slot, PyObject, PyTuple_New, PyUnicode_FromStringAndSize,
+    PyUnicode_InternFromString, PyVectorcall_NARGS,
 };
 
 use crate::util::{isize_to_usize, usize_to_isize};
 
 #[allow(unused_imports)]
-use core::ptr::{null, null_mut, NonNull};
+use core::ptr::{NonNull, null, null_mut};
 
 #[cfg(Py_3_13)]
 macro_rules! add {
@@ -424,8 +425,7 @@ pub(crate) unsafe extern "C" fn dumps(
         }
 
         let mut optsbits: i32 = 0;
-        if unlikely!(optsptr.is_some()) {
-            let opts = optsptr.unwrap();
+        if let Some(opts) = optsptr {
             if core::ptr::eq((*opts.as_ptr()).ob_type, typeref::INT_TYPE) {
                 #[allow(clippy::cast_possible_truncation)]
                 let tmp = PyLong_AsLong(optsptr.unwrap().as_ptr()) as i32; // stmt_expr_attributes
diff --git a/src/serialize/buffer.rs b/src/serialize/buffer.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use bytes::{buf::UninitSlice, BufMut};
+use bytes::{BufMut, buf::UninitSlice};
 use core::mem::MaybeUninit;
 
 const BUFFER_LENGTH: usize = 64 - core::mem::size_of::<usize>();
diff --git a/src/serialize/obtype.rs b/src/serialize/obtype.rs
@@ -5,7 +5,7 @@ use crate::opt::{
 };
 use crate::serialize::per_type::{is_numpy_array, is_numpy_scalar};
 use crate::typeref::{
-    BOOL_TYPE, DATACLASS_FIELDS_STR, DATETIME_TYPE, DATE_TYPE, DICT_TYPE, ENUM_TYPE, FLOAT_TYPE,
+    BOOL_TYPE, DATACLASS_FIELDS_STR, DATE_TYPE, DATETIME_TYPE, DICT_TYPE, ENUM_TYPE, FLOAT_TYPE,
     FRAGMENT_TYPE, INT_TYPE, LIST_TYPE, NONE_TYPE, STR_TYPE, TIME_TYPE, TUPLE_TYPE, UUID_TYPE,
 };
 
diff --git a/src/serialize/per_type/datetime.rs b/src/serialize/per_type/datetime.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use crate::opt::{Opt, OMIT_MICROSECONDS};
+use crate::opt::{OMIT_MICROSECONDS, Opt};
 use crate::serialize::buffer::SmallFixedBuffer;
 use crate::serialize::error::SerializeError;
 use crate::serialize::per_type::datetimelike::{DateTimeError, DateTimeLike, Offset};
diff --git a/src/serialize/per_type/datetimelike.rs b/src/serialize/per_type/datetimelike.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use crate::opt::{Opt, NAIVE_UTC, OMIT_MICROSECONDS, UTC_Z};
+use crate::opt::{NAIVE_UTC, OMIT_MICROSECONDS, Opt, UTC_Z};
 
 pub(crate) enum DateTimeError {
     LibraryUnsupported,
diff --git a/src/serialize/per_type/dict.rs b/src/serialize/per_type/dict.rs
@@ -3,13 +3,13 @@
 use crate::opt::{NON_STR_KEYS, NOT_PASSTHROUGH, SORT_KEYS, SORT_OR_NON_STR_KEYS};
 use crate::serialize::buffer::SmallFixedBuffer;
 use crate::serialize::error::SerializeError;
-use crate::serialize::obtype::{pyobject_to_obtype, ObType};
+use crate::serialize::obtype::{ObType, pyobject_to_obtype};
 use crate::serialize::per_type::datetimelike::DateTimeLike;
 use crate::serialize::per_type::{
     BoolSerializer, DataclassGenericSerializer, Date, DateTime, DefaultSerializer, EnumSerializer,
     FloatSerializer, FragmentSerializer, IntSerializer, ListTupleSerializer, NoneSerializer,
-    NumpyScalar, NumpySerializer, StrSerializer, StrSubclassSerializer, Time, ZeroListSerializer,
-    UUID,
+    NumpyScalar, NumpySerializer, StrSerializer, StrSubclassSerializer, Time, UUID,
+    ZeroListSerializer,
 };
 use crate::serialize::serializer::PyObjectSerializer;
 use crate::serialize::state::SerializerState;
diff --git a/src/serialize/per_type/list.rs b/src/serialize/per_type/list.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 use crate::serialize::error::SerializeError;
-use crate::serialize::obtype::{pyobject_to_obtype, ObType};
+use crate::serialize::obtype::{ObType, pyobject_to_obtype};
 use crate::serialize::per_type::{
     BoolSerializer, DataclassGenericSerializer, Date, DateTime, DefaultSerializer,
     DictGenericSerializer, EnumSerializer, FloatSerializer, FragmentSerializer, IntSerializer,
diff --git a/src/serialize/per_type/mod.rs b/src/serialize/per_type/mod.rs
@@ -27,7 +27,7 @@ pub(crate) use fragment::FragmentSerializer;
 pub(crate) use int::IntSerializer;
 pub(crate) use list::{ListTupleSerializer, ZeroListSerializer};
 pub(crate) use none::NoneSerializer;
-pub(crate) use numpy::{is_numpy_array, is_numpy_scalar, NumpyScalar, NumpySerializer};
+pub(crate) use numpy::{NumpyScalar, NumpySerializer, is_numpy_array, is_numpy_scalar};
 pub(crate) use pybool::BoolSerializer;
 pub(crate) use pyenum::EnumSerializer;
 pub(crate) use unicode::{StrSerializer, StrSubclassSerializer};
diff --git a/src/serialize/per_type/numpy.rs b/src/serialize/per_type/numpy.rs
@@ -8,12 +8,12 @@ use crate::serialize::per_type::{
 };
 use crate::serialize::serializer::PyObjectSerializer;
 use crate::str::PyStr;
-use crate::typeref::{load_numpy_types, ARRAY_STRUCT_STR, DESCR_STR, DTYPE_STR, NUMPY_TYPES};
+use crate::typeref::{ARRAY_STRUCT_STR, DESCR_STR, DTYPE_STR, NUMPY_TYPES, load_numpy_types};
 use crate::util::isize_to_usize;
 use core::ffi::{c_char, c_int, c_void};
-use jiff::civil::DateTime;
 use jiff::Timestamp;
-use pyo3_ffi::{PyObject, PyTypeObject, Py_intptr_t, Py_ssize_t};
+use jiff::civil::DateTime;
+use pyo3_ffi::{Py_intptr_t, Py_ssize_t, PyObject, PyTypeObject};
 use serde::ser::{self, Serialize, SerializeSeq, Serializer};
 use std::fmt;
 
diff --git a/src/serialize/serializer.rs b/src/serialize/serializer.rs
@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use crate::opt::{Opt, APPEND_NEWLINE, INDENT_2};
-use crate::serialize::obtype::{pyobject_to_obtype, ObType};
+use crate::opt::{APPEND_NEWLINE, INDENT_2, Opt};
+use crate::serialize::obtype::{ObType, pyobject_to_obtype};
 use crate::serialize::per_type::{
     BoolSerializer, DataclassGenericSerializer, Date, DateTime, DefaultSerializer,
     DictGenericSerializer, EnumSerializer, FloatSerializer, FragmentSerializer, IntSerializer,
     ListTupleSerializer, NoneSerializer, NumpyScalar, NumpySerializer, StrSerializer,
-    StrSubclassSerializer, Time, ZeroListSerializer, UUID,
+    StrSubclassSerializer, Time, UUID, ZeroListSerializer,
 };
 use crate::serialize::state::SerializerState;
-use crate::serialize::writer::{to_writer, to_writer_pretty, BytesWriter};
+use crate::serialize::writer::{BytesWriter, to_writer, to_writer_pretty};
 use core::ptr::NonNull;
 use serde::ser::{Serialize, Serializer};
 
diff --git a/src/serialize/writer/byteswriter.rs b/src/serialize/writer/byteswriter.rs
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 use crate::util::usize_to_isize;
-use bytes::{buf::UninitSlice, BufMut};
+use bytes::{BufMut, buf::UninitSlice};
 use core::mem::MaybeUninit;
 use core::ptr::NonNull;
-use pyo3_ffi::{PyBytesObject, PyBytes_FromStringAndSize, PyObject, PyVarObject, _PyBytes_Resize};
+use pyo3_ffi::{_PyBytes_Resize, PyBytes_FromStringAndSize, PyBytesObject, PyObject, PyVarObject};
 
 const BUFFER_LENGTH: usize = 1024;
 
diff --git a/src/serialize/writer/json.rs b/src/serialize/writer/json.rs
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 // This is an adaptation of `src/value/ser.rs` from serde-json.
 
-use crate::serialize::writer::formatter::{CompactFormatter, Formatter, PrettyFormatter};
 use crate::serialize::writer::WriteExt;
+use crate::serialize::writer::formatter::{CompactFormatter, Formatter, PrettyFormatter};
 use serde::ser::{self, Impossible, Serialize};
 use serde_json::error::{Error, Result};
 
diff --git a/src/serialize/writer/str/avx512.rs b/src/serialize/writer/str/avx512.rs
diff --git a/src/serialize/writer/str/generic.rs b/src/serialize/writer/str/generic.rs
diff --git a/src/serialize/writer/str/scalar.rs b/src/serialize/writer/str/scalar.rs
diff --git a/src/str/avx512.rs b/src/str/avx512.rs
diff --git a/src/str/mod.rs b/src/str/mod.rs
diff --git a/src/typeref.rs b/src/typeref.rs
