Fix Clippy warnings and UI tests

Author: chitoyuu

bindings-generator/src/api.rs

@@ -178,7 +178,7 @@ impl core::cmp::Ord for Enum {
 
 impl core::cmp::PartialOrd for Enum {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        core::cmp::PartialOrd::partial_cmp(&self.name, &other.name)
+        Some(self.cmp(other))
     }
 }
 

gdnative-async/src/method.rs

@@ -157,6 +157,7 @@ impl<'a, C: NativeClass, A> Spawner<'a, C, A> {
     /// Consumes this `Spawner` and spawns a future returned by the closure. This indirection
     /// is necessary so that implementors of the `AsyncMethod` trait do not have to name their
     /// future types.
+    #[allow(clippy::arc_with_non_send_sync)] // Stability concerns: part of public API
     pub fn spawn<F, R>(self, f: F)
     where
         F: FnOnce(Arc<Context>, TInstance<'_, C>, A) -> R,

gdnative-bindings/src/lib.rs

@@ -4,7 +4,7 @@
 #![allow(non_snake_case)]
 #![allow(unused_unsafe)]
 // False positives on generated drops that enforce lifetime
-#![allow(clippy::drop_copy)]
+#![allow(dropping_copy_types)]
 // False positives on thread-safe singletons
 #![allow(clippy::non_send_fields_in_send_ty)]
 // Disable non-critical lints for generated code

gdnative-core/src/export/class_registry.rs

@@ -90,10 +90,10 @@ pub(crate) fn types_with_init_level(allow: InitLevel, deny: InitLevel) -> Vec<Co
     let registry = CLASS_REGISTRY.read();
     let mut list = registry
         .values()
-        .filter_map(|class_info| {
-            (class_info.init_level.intersects(allow) && !class_info.init_level.intersects(deny))
-                .then(|| class_info.name.clone())
+        .filter(|class_info| {
+            class_info.init_level.intersects(allow) && !class_info.init_level.intersects(deny)
         })
+        .map(|class_info| class_info.name.clone())
         .collect::<Vec<_>>();
 
     list.sort_unstable();

gdnative-core/src/export/emplace.rs

@@ -42,7 +42,7 @@ pub fn take<T: NativeClass>() -> Option<T> {
             Err(any) => panic!(
                 "expecting {} in the emplacement cell, got {:?} (this is a bug in the bindings)",
                 class_registry::class_name_or_default::<T>(),
-                any.type_id(),
+                (*any).type_id(),
             ),
         })
 }

gdnative-core/src/object/mod.rs

@@ -724,7 +724,7 @@ impl<T: GodotObject, Own: Ownership> Ord for Ref<T, Own> {
 impl<T: GodotObject, Own: Ownership> PartialOrd for Ref<T, Own> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.ptr.as_non_null().partial_cmp(&other.ptr.as_non_null())
+        Some(self.cmp(other))
     }
 }
 
@@ -863,7 +863,7 @@ impl<'a, T: GodotObject, Own: Ownership> Copy for TRef<'a, T, Own> {}
 impl<'a, T: GodotObject, Own: Ownership> Clone for TRef<'a, T, Own> {
     #[inline]
     fn clone(&self) -> Self {
-        TRef::new(self.obj)
+        *self
     }
 }
 

gdnative-core/src/object/raw.rs

@@ -70,7 +70,7 @@ impl<T: GodotObject> RawObject<T> {
     pub fn class_name(&self) -> String {
         let api = crate::private::get_api();
         let get_class_method = crate::private::ObjectMethodTable::get(api).get_class;
-        let mut argument_buffer = [ptr::null() as *const libc::c_void; 0];
+        let mut argument_buffer: [*const libc::c_void; 0] = [];
         let mut class_name = sys::godot_string::default();
         let ret_ptr = &mut class_name as *mut sys::godot_string;
 
@@ -127,7 +127,7 @@ impl<T: GodotObject<Memory = RefCounted>> RawObject<T> {
     pub fn add_ref(&self) {
         let api = crate::private::get_api();
         let addref_method = crate::private::ReferenceMethodTable::get(api).reference;
-        let mut argument_buffer = [ptr::null() as *const libc::c_void; 0];
+        let mut argument_buffer: [*const libc::c_void; 0] = [];
         let mut ok = false;
         let ok_ptr = &mut ok as *mut bool;
 
@@ -158,7 +158,7 @@ impl<T: GodotObject<Memory = RefCounted>> RawObject<T> {
         let api = crate::private::get_api();
         let unref_method = crate::private::ReferenceMethodTable::get(api).unreference;
 
-        let mut argument_buffer = [ptr::null() as *const libc::c_void; 0];
+        let mut argument_buffer: [*const libc::c_void; 0] = [];
         let mut last_reference = false;
         let ret_ptr = &mut last_reference as *mut bool;
         (api.godot_method_bind_ptrcall)(
@@ -201,7 +201,7 @@ impl<T: GodotObject<Memory = RefCounted>> RawObject<T> {
         let api = crate::private::get_api();
         let init_method = crate::private::ReferenceMethodTable::get(api).init_ref;
 
-        let mut argument_buffer = [ptr::null() as *const libc::c_void; 0];
+        let mut argument_buffer: [*const libc::c_void; 0] = [];
         let mut ok = false;
         let ret_ptr = &mut ok as *mut bool;
         (api.godot_method_bind_ptrcall)(
@@ -237,7 +237,7 @@ unsafe fn ptr_is_class(obj: *mut sys::godot_object, class_name: &str) -> bool {
         class_name.len() as _,
     );
 
-    let mut argument_buffer = [ptr::null() as *const libc::c_void; 1];
+    let mut argument_buffer: [*const libc::c_void; 1] = [ptr::null(); 1];
     argument_buffer[0] = (&class_name) as *const _ as *const _;
 
     let mut ret = false;

gdnative-derive/src/methods.rs

@@ -568,8 +568,7 @@ fn impl_gdnative_expose(ast: ItemImpl) -> (ItemImpl, ClassMethodExport) {
 
                         if is_export {
                             use syn::{punctuated::Punctuated, Lit};
-                            let mut export_args =
-                                export_args.get_or_insert_with(ExportArgs::default);
+                            let export_args = export_args.get_or_insert_with(ExportArgs::default);
                             export_args.is_old_syntax = is_old_syntax;
 
                             // Codes like #[macro(path, name = "value")] are accepted.

gdnative/tests/ui/derive_fail_methods_special_args.rs

@@ -11,13 +11,13 @@ impl Foo {
     }
 
     #[method]
-    async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] ctx: ()) {}
+    async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] _ctx: ()) {}
 
     #[method]
     fn based(#[base] self, #[base] _base: &Node, #[base] #[base] _basil: &Node, #[base] #[base] #[base] _basin: &Node) {}
 
     #[method]
-    fn sync(self, #[async_ctx] ctx: ()) {}
+    fn sync(self, #[async_ctx] _ctx: ()) {}
 }
 
 fn main() {}

gdnative/tests/ui/derive_fail_methods_special_args.stderr

@@ -1,19 +1,19 @@
 error: the method receiver cannot be optional (instead, remove the argument entirely)
   --> tests/ui/derive_fail_methods_special_args.rs:14:25
    |
-14 |     async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] ctx: ()) {}
+14 |     async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] _ctx: ()) {}
    |                         ^^^
 
 error: the base/owner object cannot be optional (instead, remove the argument entirely)
   --> tests/ui/derive_fail_methods_special_args.rs:14:46
    |
-14 |     async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] ctx: ()) {}
+14 |     async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] _ctx: ()) {}
    |                                              ^^^
 
 error: the async context cannot be optional (instead, remove the argument entirely)
   --> tests/ui/derive_fail_methods_special_args.rs:14:80
    |
-14 |     async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] ctx: ()) {}
+14 |     async fn optional(#[opt] self, #[base] #[opt] _base: &Node, #[async_ctx] #[opt] _ctx: ()) {}
    |                                                                                ^^^
 
 error: the method receiver cannot also be the base/owner object
@@ -55,5 +55,5 @@ error: the special parameter base/owner object must only be declared once (the s
 error: the async context is only available to async methods
   --> tests/ui/derive_fail_methods_special_args.rs:20:32
    |
-20 |     fn sync(self, #[async_ctx] ctx: ()) {}
-   |                                ^^^
+20 |     fn sync(self, #[async_ctx] _ctx: ()) {}
+   |                                ^^^^