Allow #[cfg] to be used with #[func]

Author: PgBiel

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

@@ -194,6 +194,12 @@ impl GetterSetterImpl {
             class_name,
             FuncDefinition {
                 func: signature,
+                // Since we're analyzing a struct's field, we don't have access to the corresponding get/set function's
+                // external (non-#[func]) attributes. We have to assume the function exists and has the name the user
+                // gave us, with the expected signature.
+                // Ideally, we'd be able to place #[cfg_attr] on #[var(get)] and #[var(set)] to be able to match a
+                // #[cfg()] (for instance) placed on the getter/setter function, but that is not currently supported.
+                external_attributes: Vec::new(),
                 rename: None,
                 has_gd_self: false,
             },

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

@@ -12,6 +12,8 @@ use quote::{format_ident, quote};
 pub struct FuncDefinition {
     /// Raw information about the Rust function.
     pub func: venial::Function,
+    /// The function's non-gdext attributes (that is, excluding #[func]).
+    pub external_attributes: Vec<venial::Attribute>,
     /// The name the function will be exposed as in Godot. If `None`, the Rust function name is used.
     pub rename: Option<String>,
     pub has_gd_self: bool,
@@ -78,7 +80,14 @@ pub fn make_method_registration(
     };
     let param_ident_strs = param_idents.iter().map(|ident| ident.to_string());
 
+    // Transport #[cfg] attrs to the FFI glue to ensure functions which were conditionally
+    // removed from compilation don't cause errors.
+    let cfg_attrs = util::extract_cfg_attrs(&func_definition.external_attributes)
+        .into_iter()
+        .collect::<Vec<_>>();
+
     quote! {
+        #(#cfg_attrs)*
         {
             use ::godot::obj::GodotClass;
             use ::godot::builtin::meta::registration::method::MethodInfo;

godot-macros/src/class/godot_api.rs

@@ -238,6 +238,7 @@ fn process_godot_fns(decl: &mut Impl) -> Result<(Vec<FuncDefinition>, Vec<Functi
                     rename,
                     has_gd_self,
                 } => {
+                    let external_attributes = method.attributes.clone();
                     // Signatures are the same thing without body
                     let mut sig = util::reduce_to_signature(method);
                     if *has_gd_self {
@@ -249,6 +250,7 @@ fn process_godot_fns(decl: &mut Impl) -> Result<(Vec<FuncDefinition>, Vec<Functi
                     }
                     func_definitions.push(FuncDefinition {
                         func: sig,
+                        external_attributes,
                         rename: rename.clone(),
                         has_gd_self: *has_gd_self,
                     });

godot-macros/src/util/mod.rs

@@ -227,6 +227,15 @@ pub(crate) fn path_ends_with(path: &[TokenTree], expected: &str) -> bool {
         .unwrap_or(false)
 }
 
+pub(crate) fn extract_cfg_attrs(
+    attrs: &[venial::Attribute],
+) -> impl IntoIterator<Item = &venial::Attribute> {
+    attrs.iter().filter(|attr| {
+        attr.get_single_path_segment()
+            .map_or(false, |name| name == "cfg")
+    })
+}
+
 pub(crate) struct DeclInfo {
     pub where_: Option<WhereClause>,
     pub generic_params: Option<GenericParamList>,

itest/rust/src/register_tests/func_test.rs

@@ -7,6 +7,8 @@
 // Needed for Clippy to accept #[cfg(all())]
 #![allow(clippy::non_minimal_cfg)]
 
+use crate::framework::itest;
+use godot::engine::ClassDb;
 use godot::prelude::*;
 
 #[derive(GodotClass)]
@@ -29,6 +31,26 @@ impl FuncRename {
     fn renamed_static() -> GodotString {
         GodotString::from("static")
     }
+
+    #[cfg(all())]
+    fn returns_hello_world(&self) -> GodotString {
+        GodotString::from("Hello world!")
+    }
+
+    #[cfg(any())]
+    fn returns_hello_world(&self) -> GodotString {
+        compile_error!("Removed by #[cfg]")
+    }
+
+    #[cfg(any())]
+    fn returns_bye_world(&self) -> GodotString {
+        compile_error!("Removed by #[cfg]")
+    }
+
+    #[cfg(all())]
+    fn returns_bye_world(&self) -> GodotString {
+        GodotString::from("Bye world!")
+    }
 }
 
 impl FuncRename {
@@ -89,6 +111,35 @@ impl GdSelfReference {
         f1 && f2
     }
 
+    #[func]
+    fn cfg_removes_function() -> bool {
+        true
+    }
+
+    #[cfg(any())]
+    #[func]
+    fn cfg_removes_function() -> bool {
+        false
+    }
+
+    #[func]
+    #[cfg(any())]
+    fn cfg_removes_function() -> bool {
+        false
+    }
+
+    #[cfg(any())]
+    #[func]
+    fn cfg_removes_function_ffi_glue() -> bool {
+        true
+    }
+
+    #[func]
+    #[cfg(any())]
+    fn cfg_removes_function_ffi_glue() -> bool {
+        true
+    }
+
     #[signal]
     #[rustfmt::skip]
     fn signal_shouldnt_panic_with_segmented_path_attribute();
@@ -148,3 +199,36 @@ impl RefCountedVirtual for GdSelfReference {
         }
     }
 }
+
+#[itest]
+fn cfg_doesnt_interfere_with_valid_method_impls() {
+    // if we re-implement this method but the re-implementation is removed, that should keep the non-removed
+    // implementation.
+    let object = Gd::new(FuncRename);
+    assert_eq!(
+        object.bind().returns_hello_world(),
+        GodotString::from("Hello world!")
+    );
+    assert_eq!(
+        object.bind().returns_bye_world(),
+        GodotString::from("Bye world!")
+    );
+}
+
+#[itest]
+fn cfg_removes_or_keeps_methods() {
+    let has_method = |name: &str| {
+        ClassDb::singleton()
+            .class_has_method_ex(GdSelfReference::class_name().to_string_name(), name.into())
+            .no_inheritance(true)
+            .done()
+    };
+    assert!(has_method(
+        "func_recognized_with_simple_path_attribute_above_func_attr"
+    ));
+    assert!(has_method(
+        "func_recognized_with_simple_path_attribute_below_func_attr"
+    ));
+    assert!(has_method("cfg_removes_function"));
+    assert!(!has_method("cfg_removes_function_ffi_glue"));
+}