Merge #837

837: Allow `impl Into<NodePath>` for `NodeExt` methods and simplify impls r=Bromeon a=Waridley

For reference, as discussed several months ago in Discord:
> Part of the problem is that using `impl Into<NodePath>` means that you can no longer explicitly declare `T` with e.g. `owner.get_node_as::<Node>(path)`, because the compiler complains about `impl Trait` creating an implicit type parameter. But turning it into
> ```rust
> unsafe fn get_node_as<'a, T, P>(&self, path: P) -> Option<TRef<'a, T>>
> where
>   T: SubClass<Node>,
>   P: Into<NodePath>;
> ```
> Means you have to always either declare the type of the path argument, or use `get_node_as::<Node, _>(path)`

Eventually I came up with the solution of putting the path generic parameter in the trait declaration rather than the methods, and haven't been able to come up with a significant drawback.

Just today I realized there was little reason to have impls for both `&T` and `TRef` when all methods already take `&self` -- the compiler will auto-dereference `TRef`s, and this will also let it work with unique & thread-local `Ref`s.

Co-authored-by: Waridley <[email protected]>

Author: bors[bot]

gdnative-bindings/src/utils.rs

@@ -1,5 +1,6 @@
 //! Utility functions and extension traits that depend on generated bindings
 
+use gdnative_core::core_types::NodePath;
 use gdnative_core::export::NativeClass;
 use gdnative_core::object::{SubClass, TInstance, TRef};
 
@@ -30,7 +31,7 @@ where
         .cast::<T>()
 }
 
-pub trait NodeExt {
+pub trait NodeResolveExt<P: Into<NodePath>> {
     /// Convenience method to obtain a reference to a node at `path` relative to `self`,
     /// and cast it to the desired type. Returns `None` if the node does not exist or is
     /// not of the correct type.
@@ -42,7 +43,7 @@ pub trait NodeExt {
     /// invariants must be observed for the resulting node during `'a`, if any.
     ///
     /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-    unsafe fn get_node_as<'a, T>(&self, path: &str) -> Option<TRef<'a, T>>
+    unsafe fn get_node_as<'a, T>(&self, path: P) -> Option<TRef<'a, T>>
     where
         T: SubClass<Node>;
 
@@ -57,7 +58,7 @@ pub trait NodeExt {
     /// invariants must be observed for the resulting node during `'a`, if any.
     ///
     /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-    unsafe fn get_node_as_instance<'a, T>(&self, path: &str) -> Option<TInstance<'a, T>>
+    unsafe fn get_node_as_instance<'a, T>(&self, path: P) -> Option<TInstance<'a, T>>
     where
         T: NativeClass,
         T::Base: SubClass<Node>,
@@ -66,20 +67,11 @@ pub trait NodeExt {
     }
 }
 
-impl<'n, N: SubClass<Node>> NodeExt for &'n N {
-    unsafe fn get_node_as<'a, T>(&self, path: &str) -> Option<TRef<'a, T>>
+impl<N: SubClass<Node>, P: Into<NodePath>> NodeResolveExt<P> for N {
+    unsafe fn get_node_as<'a, T>(&self, path: P) -> Option<TRef<'a, T>>
     where
         T: SubClass<Node>,
     {
         self.upcast().get_node(path)?.assume_safe().cast()
     }
 }
-
-impl<'n, N: SubClass<Node>> NodeExt for TRef<'n, N> {
-    unsafe fn get_node_as<'a, T>(&self, path: &str) -> Option<TRef<'a, T>>
-    where
-        T: SubClass<Node>,
-    {
-        self.as_ref().get_node_as(path)
-    }
-}

test/src/test_as_arg.rs

@@ -1,5 +1,5 @@
 use gdnative::derive::{methods, NativeClass};
-use gdnative::prelude::NodeExt;
+use gdnative::prelude::NodeResolveExt;
 use gdnative::prelude::*;
 use std::ops::Deref;