Virtual methods: selectively inherit/override/remove optional/required-ness from base

Author: Bromeon

godot-codegen/src/generator/virtual_traits.rs

@@ -8,7 +8,7 @@
 use crate::generator::functions_common::FnCode;
 use crate::generator::{docs, functions_common};
 use crate::models::domain::{
-    ApiView, Class, ClassLike, ClassMethod, FnQualifier, Function, TyName,
+    ApiView, Class, ClassLike, ClassMethod, FnQualifier, Function, TyName, VirtualMethodPresence,
 };
 use crate::special_cases;
 use crate::util::ident;
@@ -153,12 +153,20 @@ fn make_special_virtual_methods(notification_enum_name: &Ident) -> TokenStream {
 
 fn make_virtual_method(
     method: &ClassMethod,
-    override_is_required: Option<bool>,
+    presence: VirtualMethodPresence,
 ) -> Option<TokenStream> {
     if !method.is_virtual() {
         return None;
     }
 
+    // Possibly change behavior of required/optional-ness of the virtual method in derived classes.
+    // It's also possible that it's removed, which would not declare it at all in the `I*` trait.
+    let is_virtual_required = match presence {
+        VirtualMethodPresence::Inherit => method.is_virtual_required(),
+        VirtualMethodPresence::Override { is_required } => is_required,
+        VirtualMethodPresence::Remove => return None,
+    };
+
     // Virtual methods are never static.
     let qualifier = method.qualifier();
     assert!(matches!(qualifier, FnQualifier::Mut | FnQualifier::Const));
@@ -170,8 +178,7 @@ fn make_virtual_method(
             // make_return() requests following args, but they are not used for virtual methods. We can provide empty streams.
             varcall_invocation: TokenStream::new(),
             ptrcall_invocation: TokenStream::new(),
-            is_virtual_required: override_is_required
-                .unwrap_or_else(|| method.is_virtual_required()),
+            is_virtual_required,
             is_varcall_fallible: true,
         },
         None,
@@ -191,7 +198,7 @@ fn make_all_virtual_methods(
 
     for method in class.methods.iter() {
         // Assumes that inner function filters on is_virtual.
-        if let Some(tokens) = make_virtual_method(method, None) {
+        if let Some(tokens) = make_virtual_method(method, VirtualMethodPresence::Inherit) {
             all_tokens.push(tokens);
         }
     }
@@ -201,14 +208,17 @@ fn make_all_virtual_methods(
         for method in base_class.methods.iter() {
             // Certain derived classes in Godot implement a virtual method declared in a base class, thus no longer
             // making it required. This isn't advertised in the extension_api, but instead manually tracked via special cases.
-            let is_required =
-                special_cases::is_derived_virtual_method_required(class.name(), method.name());
+            let derived_presence =
+                special_cases::get_derived_virtual_method_presence(class.name(), method.name());
 
-            if let Some(tokens) = make_virtual_method(method, is_required) {
+            if let Some(tokens) = make_virtual_method(method, derived_presence) {
                 all_tokens.push(tokens);
             }
         }
     }
 
     all_tokens
 }
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Helper types

godot-codegen/src/models/domain.rs

@@ -723,6 +723,20 @@ pub enum ArgPassing {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
+/// Behavior of virtual methods in derived classes.
+pub enum VirtualMethodPresence {
+    /// Preserve default behavior of base class (required or optional).
+    Inherit,
+
+    /// Virtual method is now required/optional according to `is_required`, independent of base method declaration.
+    Override { is_required: bool },
+
+    /// Virtual method is removed in derived classes (no longer appearing in their interface trait).
+    Remove,
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 /// Contains multiple naming conventions for types (classes, builtin classes, enums).
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub struct TyName {

godot-codegen/src/special_cases/special_cases.rs

@@ -26,7 +26,7 @@
 #![allow(clippy::match_like_matches_macro)] // if there is only one rule
 
 use crate::conv::to_enum_type_uncached;
-use crate::models::domain::{Enum, RustTy, TyName};
+use crate::models::domain::{Enum, RustTy, TyName, VirtualMethodPresence};
 use crate::models::json::{JsonBuiltinMethod, JsonClassMethod, JsonSignal, JsonUtilityFunction};
 use crate::special_cases::codegen_special_cases;
 use crate::util::option_as_slice;
@@ -847,12 +847,14 @@ pub fn is_virtual_method_required(class_name: &TyName, rust_method_name: &str) -
 
 // Adjustments for Godot 4.4+, where a virtual method is no longer needed (e.g. in a derived class).
 #[rustfmt::skip]
-pub fn is_derived_virtual_method_required(class_name: &TyName, rust_method_name: &str) -> Option<bool> {
-      match (class_name.godot_ty.as_str(), rust_method_name) {
-          // Required in base class, no longer in derived; https://github.com/godot-rust/gdext/issues/1133.
-          | ("AudioStreamPlaybackResampled", "mix")
-        
-          => Some(false), _ => None
+pub fn get_derived_virtual_method_presence(class_name: &TyName, rust_method_name: &str) -> VirtualMethodPresence {
+     match (class_name.godot_ty.as_str(), rust_method_name) {
+         // Required in base class, no longer in derived; https://github.com/godot-rust/gdext/issues/1133.
+         | ("AudioStreamPlaybackResampled", "mix")
+         => VirtualMethodPresence::Remove,
+
+         // Default: inherit presence from base class.
+         _ => VirtualMethodPresence::Inherit,
     }
 }