Consistent #[derive] order + smaller formatting

Author: Bromeon

godot-core/src/builtin/array.rs

@@ -597,17 +597,17 @@ unsafe impl<T: VariantMetadata> GodotFfi for Array<T> {
         fn move_return_ptr;
     }
 
-    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
-        let array = Self::from_sys(ptr);
-        std::mem::forget(array.share());
-        array
-    }
-
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();
         init_fn(result.sys_mut());
         result
     }
+
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
+        let array = Self::from_sys(ptr);
+        std::mem::forget(array.share());
+        array
+    }
 }
 
 impl<T: VariantMetadata> fmt::Debug for Array<T> {

godot-core/src/builtin/basis.rs

@@ -579,7 +579,7 @@ unsafe impl GodotFfi for Basis {
 
 /// The ordering used to interpret a set of euler angles as extrinsic
 /// rotations.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
 #[repr(C)]
 pub enum EulerOrder {
     XYZ = 0,

godot-core/src/builtin/color.rs

@@ -15,15 +15,18 @@ use sys::{ffi_methods, GodotFfi};
 /// Channel values are _typically_ in the range of 0 to 1, but this is not a requirement, and
 /// values outside this range are explicitly allowed for e.g. High Dynamic Range (HDR).
 #[repr(C)]
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Color {
     /// The color's red component.
     pub r: f32,
+
     /// The color's green component.
     pub g: f32,
+
     /// The color's blue component.
     pub b: f32,
+
     /// The color's alpha component. A value of 0 means that the color is fully transparent. A
     /// value of 1 means that the color is fully opaque.
     pub a: f32,
@@ -318,12 +321,14 @@ unsafe impl GodotFfi for Color {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum ColorChannelOrder {
     /// RGBA channel order. Godot's default.
     Rgba,
+
     /// ABGR channel order. Reverse of the default RGBA order.
     Abgr,
+
     /// ARGB channel order. More compatible with DirectX.
     Argb,
 }

godot-core/src/builtin/dictionary.rs

@@ -262,17 +262,17 @@ unsafe impl GodotFfi for Dictionary {
         fn move_return_ptr;
     }
 
-    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
-        let dictionary = Self::from_sys(ptr);
-        std::mem::forget(dictionary.share());
-        dictionary
-    }
-
     unsafe fn from_sys_init_default(init_fn: impl FnOnce(sys::GDExtensionTypePtr)) -> Self {
         let mut result = Self::default();
         init_fn(result.sys_mut());
         result
     }
+
+    unsafe fn from_arg_ptr(ptr: sys::GDExtensionTypePtr, _call_type: sys::PtrcallType) -> Self {
+        let dictionary = Self::from_sys(ptr);
+        std::mem::forget(dictionary.share());
+        dictionary
+    }
 }
 
 impl_builtin_traits! {

godot-core/src/builtin/meta/class_name.rs

@@ -13,7 +13,7 @@ use crate::obj::GodotClass;
 
 /// Utility to construct class names known at compile time.
 /// Cannot be a function since the backing string must be retained.
-#[derive(Eq, PartialEq, Hash, Clone, Debug)]
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct ClassName {
     backing: StringName,
 }

godot-core/src/builtin/projection.rs

@@ -494,7 +494,7 @@ unsafe impl GodotFfi for Projection {
 }
 
 /// A projections clipping plane.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 #[repr(C)]
 pub enum ProjectionPlane {
     Near = 0,
@@ -507,7 +507,7 @@ pub enum ProjectionPlane {
 
 /// The eye to create a projection for, when creating a projection adjusted
 /// for head-mounted displays.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 #[repr(C)]
 pub enum ProjectionEye {
     Left = 1,

godot-core/src/builtin/rect2i.rs

@@ -20,6 +20,7 @@ use super::{Rect2, RectSide, Vector2i};
 pub struct Rect2i {
     /// The position of the rectangle.
     pub position: Vector2i,
+
     /// The size of the rectangle.
     pub size: Vector2i,
 }

godot-core/src/builtin/rid.rs

@@ -30,10 +30,11 @@ use sys::{ffi_methods, GodotFfi};
 // eligible for it, it is also guaranteed to have it. Meaning the layout of this type is identical to `u64`.
 // See: https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization
 // Cannot use `#[repr(C)]` as it does not use the nullable pointer optimization.
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd, Debug)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub enum Rid {
     /// A valid RID may refer to some resource, but is not guaranteed to do so.
     Valid(NonZeroU64),
+
     /// An invalid RID will never refer to a resource. Internally it is represented as a 0.
     Invalid,
 }

godot-core/src/builtin/variant/mod.rs

@@ -201,16 +201,12 @@ impl Variant {
     }
 
     /// Converts to variant pointer; can be a null pointer.
-    pub(crate) fn ptr_from_sys(
-        variant_ptr: sys::GDExtensionVariantPtr,
-    ) -> *const Variant {
+    pub(crate) fn ptr_from_sys(variant_ptr: sys::GDExtensionVariantPtr) -> *const Variant {
         variant_ptr as *const Variant
     }
 
     /// Converts to variant mut pointer; can be a null pointer.
-    pub(crate) fn ptr_from_sys_mut(
-        variant_ptr: sys::GDExtensionVariantPtr,
-    ) -> *mut Variant {
+    pub(crate) fn ptr_from_sys_mut(variant_ptr: sys::GDExtensionVariantPtr) -> *mut Variant {
         variant_ptr as *mut Variant
     }
 }

godot-core/src/builtin/variant/variant_traits.rs

@@ -49,7 +49,7 @@ pub trait ToVariant {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Eq, PartialEq, Debug)]
 pub struct VariantConversionError;
 /*pub enum VariantConversionError {
     /// Variant type does not match expected type

godot-core/src/builtin/vector2.rs

@@ -26,12 +26,13 @@ use super::{real, RAffine2, RVec2};
 /// vectors; use the gdext library with the `double-precision` feature in that case.
 ///
 /// See [`Vector2i`] for its integer counterpart.
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
+#[derive(Default, Copy, Clone, PartialEq, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub struct Vector2 {
     /// The vector's X component.
     pub x: real,
+
     /// The vector's Y component.
     pub y: real,
 }
@@ -318,11 +319,12 @@ unsafe impl GodotFfi for Vector2 {
 }
 
 /// Enumerates the axes in a [`Vector2`].
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[repr(i32)]
 pub enum Vector2Axis {
     /// The X axis.
     X,
+
     /// The Y axis.
     Y,
 }

godot-core/src/builtin/vector2i.rs

@@ -23,12 +23,13 @@ use super::IVec2;
 /// required. Note that the values are limited to 32 bits, and unlike [`Vector2`] this cannot be
 /// configured with an engine build option. Use `i64` or [`PackedInt64Array`] if 64-bit values are
 /// needed.
-#[derive(Debug, Default, Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub struct Vector2i {
     /// The vector's X component.
     pub x: i32,
+
     /// The vector's Y component.
     pub y: i32,
 }
@@ -99,11 +100,12 @@ unsafe impl GodotFfi for Vector2i {
 }
 
 /// Enumerates the axes in a [`Vector2i`].
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 #[repr(i32)]
 pub enum Vector2iAxis {
     /// The X axis.
     X,
+
     /// The Y axis.
     Y,
 }

godot-core/src/builtin/vector3.rs

@@ -27,14 +27,16 @@ use super::{real, Basis, RVec3};
 /// vectors; use the gdext library with the `double-precision` feature in that case.
 ///
 /// See [`Vector3i`] for its integer counterpart.
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
+#[derive(Default, Copy, Clone, PartialEq, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub struct Vector3 {
     /// The vector's X component.
     pub x: real,
+
     /// The vector's Y component.
     pub y: real,
+
     /// The vector's Z component.
     pub z: real,
 }
@@ -338,13 +340,15 @@ unsafe impl GodotFfi for Vector3 {
 
 /// Enumerates the axes in a [`Vector3`].
 // TODO auto-generate this, alongside all the other builtin type's enums
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[repr(i32)]
 pub enum Vector3Axis {
     /// The X axis.
     X,
+
     /// The Y axis.
     Y,
+
     /// The Z axis.
     Z,
 }

godot-core/src/builtin/vector3i.rs

@@ -23,14 +23,16 @@ use super::IVec3;
 /// required. Note that the values are limited to 32 bits, and unlike [`Vector3`] this cannot be
 /// configured with an engine build option. Use `i64` or [`PackedInt64Array`] if 64-bit values are
 /// needed.
-#[derive(Debug, Default, Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub struct Vector3i {
     /// The vector's X component.
     pub x: i32,
+
     /// The vector's Y component.
     pub y: i32,
+
     /// The vector's Z component.
     pub z: i32,
 }
@@ -113,8 +115,10 @@ unsafe impl GodotFfi for Vector3i {
 pub enum Vector3iAxis {
     /// The X axis.
     X,
+
     /// The Y axis.
     Y,
+
     /// The Z axis.
     Z,
 }

godot-core/src/builtin/vector4.rs

@@ -24,16 +24,19 @@ use super::{real, RVec4};
 /// vectors; use the gdext library with the `double-precision` feature in that case.
 ///
 /// See [`Vector4i`] for its integer counterpart.
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
+#[derive(Default, Copy, Clone, PartialEq, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub struct Vector4 {
     /// The vector's X component.
     pub x: real,
+
     /// The vector's Y component.
     pub y: real,
+
     /// The vector's Z component.
     pub z: real,
+
     /// The vector's W component.
     pub w: real,
 }
@@ -105,15 +108,18 @@ unsafe impl GodotFfi for Vector4 {
 }
 
 /// Enumerates the axes in a [`Vector4`].
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[repr(i32)]
 pub enum Vector4Axis {
     /// The X axis.
     X,
+
     /// The Y axis.
     Y,
+
     /// The Z axis.
     Z,
+
     /// The W axis.
     W,
 }

godot-core/src/builtin/vector4i.rs

@@ -22,16 +22,19 @@ use super::IVec4;
 /// required. Note that the values are limited to 32 bits, and unlike [`Vector4`] this cannot be
 /// configured with an engine build option. Use `i64` or [`PackedInt64Array`] if 64-bit values are
 /// needed.
-#[derive(Debug, Default, Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[repr(C)]
 pub struct Vector4i {
     /// The vector's X component.
     pub x: i32,
+
     /// The vector's Y component.
     pub y: i32,
+
     /// The vector's Z component.
     pub z: i32,
+
     /// The vector's W component.
     pub w: i32,
 }
@@ -93,15 +96,18 @@ unsafe impl GodotFfi for Vector4i {
 }
 
 /// Enumerates the axes in a [`Vector4i`].
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[repr(i32)]
 pub enum Vector4iAxis {
     /// The X axis.
     X,
+
     /// The Y axis.
     Y,
+
     /// The Z axis.
     Z,
+
     /// The W axis.
     W,
 }

godot-core/src/obj/instance_id.rs

@@ -15,7 +15,7 @@ use std::num::NonZeroU64;
 ///
 /// This is its own type for type safety and to deal with the inconsistent representation in Godot as both `u64` (C++) and `i64` (GDScript).
 /// You can usually treat this as an opaque value and pass it to and from GDScript; there are conversion methods however.
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[repr(transparent)]
 pub struct InstanceId {
     // Note: in the public API, signed i64 is the canonical representation.

godot-core/src/registry.rs

@@ -44,7 +44,7 @@ impl Debug for ErasedRegisterFn {
 }
 
 /// Represents the data part of a [`ClassPlugin`] instance.
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
 pub enum PluginComponent {
     /// Class definition itself, must always be available
     ClassDef {

godot-ffi/src/godot_ffi.rs

@@ -103,6 +103,7 @@ pub enum PtrcallType {
     /// return value must be moved into the return pointer.
     #[default]
     Standard,
+
     /// Virtual pointer call.
     ///
     /// A virtual call behaves like [`PtrcallType::Standard`], except for `RefCounted` objects.