Virtual dispatch: fix incorrect matching of renamed virtual methods

A handful of virtual methods are renamed during codegen, however #[godot_api]
always matches against the Rust name (with added `_` prefix).

Now stores the Godot names in the same global constants as the hashes.

Author: Bromeon

godot-codegen/src/generator/virtual_hashes.rs

@@ -43,9 +43,10 @@ fn make_virtual_hashes_for_class(class: &Class, ctx: &mut Context) -> TokenStrea
             return None;
         };
 
-        let method_name = method.name_ident();
+        let rust_name = method.name_ident();
+        let godot_name_str = method.godot_name();
         let constant = quote! {
-            pub const #method_name: u32 = #hash;
+            pub const #rust_name: (&'static str, u32) = (#godot_name_str, #hash);
         };
 
         Some(constant)

godot-macros/src/class/data_models/interface_trait_impl.rs

@@ -102,14 +102,14 @@ pub fn transform_trait_impl(mut original_impl: venial::Impl) -> ParseResult<Toke
         && !decls
             .overridden_virtuals
             .iter()
-            .any(|v| v.method_name == "_ready")
+            .any(|v| v.rust_method_name == "_ready")
     {
         let match_arm = OverriddenVirtualFn {
             cfg_attrs: vec![],
-            method_name: "_ready".to_string(),
+            rust_method_name: "_ready".to_string(),
             // Can't use `hashes::ready` here, as the base class might not be `Node` (see above why such a branch is still added).
             #[cfg(since_api = "4.4")]
-            hash_constant: quote! { ::godot::sys::known_virtual_hashes::Node::ready },
+            godot_name_hash_constant: quote! { ::godot::sys::known_virtual_hashes::Node::ready },
             signature_info: SignatureInfo::fn_ready(),
             before_kind: BeforeKind::OnlyBefore,
             interface_trait: None,
@@ -518,12 +518,12 @@ fn handle_regular_virtual_fn<'a>(
     // each distinct method.
     decls.overridden_virtuals.push(OverriddenVirtualFn {
         cfg_attrs,
-        method_name: virtual_method_name,
+        rust_method_name: virtual_method_name,
         // If ever the `I*` verbatim validation is relaxed (it won't work with use-renames or other weird edge cases), the approach
         // with known_virtual_hashes module could be changed to something like the following (GodotBase = nearest Godot base class):
         // __get_virtual_hash::<Self::GodotBase>("method")
         #[cfg(since_api = "4.4")]
-        hash_constant: quote! { hashes::#method_name_ident },
+        godot_name_hash_constant: quote! { hashes::#method_name_ident },
         signature_info,
         before_kind,
         interface_trait: Some(trait_path.clone()),
@@ -573,9 +573,10 @@ fn make_inactive_class_check(_return_value: TokenStream) -> TokenStream {
 
 struct OverriddenVirtualFn<'a> {
     cfg_attrs: Vec<&'a venial::Attribute>,
-    method_name: String,
+    rust_method_name: String,
+    /// Path to a pre-defined constant storing a `("_virtual_func", 123456789)` tuple with name and hash of the virtual function.
     #[cfg(since_api = "4.4")]
-    hash_constant: TokenStream,
+    godot_name_hash_constant: TokenStream,
     signature_info: SignatureInfo,
     before_kind: BeforeKind,
     interface_trait: Option<venial::TypeExpr>,
@@ -584,16 +585,16 @@ struct OverriddenVirtualFn<'a> {
 impl OverriddenVirtualFn<'_> {
     fn make_match_arm(&self, class_name: &Ident) -> TokenStream {
         let cfg_attrs = self.cfg_attrs.iter();
-        let method_name_str = self.method_name.as_str();
 
         #[cfg(since_api = "4.4")]
         let pattern = {
-            let hash_constant = &self.hash_constant;
-            quote! { (#method_name_str, #hash_constant) }
+            let godot_name_hash_constant = &self.godot_name_hash_constant;
+            quote! { #godot_name_hash_constant }
         };
 
+        // Note: this is wrong before 4.4, as some methods are renamed in Rust.
         #[cfg(before_api = "4.4")]
-        let pattern = method_name_str;
+        let pattern = self.rust_method_name.as_str();
 
         // Lazily generate code for the actual work (calling user function).
         let method_callback = make_virtual_callback(

godot-macros/src/class/derive_godot_class.rs

@@ -400,13 +400,15 @@ fn make_user_class_impl(
         // See also __virtual_call() codegen.
         // This doesn't explicitly check if the base class inherits from Node (and thus has `_ready`), but the derive-macro already does
         // this for the `OnReady` field declaration.
-        let (hash_param, hash_check);
+        let (hash_param, matches_ready_hash);
         if cfg!(since_api = "4.4") {
             hash_param = quote! { hash: u32, };
-            hash_check = quote! { && hash == ::godot::sys::known_virtual_hashes::Node::ready };
+            matches_ready_hash = quote! {
+                (name, hash) == ::godot::sys::known_virtual_hashes::Node::ready
+            };
         } else {
             hash_param = TokenStream::new();
-            hash_check = TokenStream::new();
+            matches_ready_hash = quote! { name == "_ready" }
         }
 
         let default_virtual_fn = quote! {
@@ -417,7 +419,7 @@ fn make_user_class_impl(
                 use ::godot::obj::UserClass as _;
                 #tool_check
 
-                if name == "_ready" #hash_check {
+                if #matches_ready_hash {
                     #callback
                 } else {
                     None