parse no_mangle in cfg_attr

fixes rksm#36

the predicate currently isn't checked, which may cause false positives,
but this is very unlikely to happen and this can be dealt with in the future.
the relevant documentation and example have been adjusted.

the documentation for #[no_mangle_if_debug] has been removed since it doesn't
work with optimizations or the feature flag anyways.
it should later be deprecated and phased out.

README.md

@@ -264,9 +264,10 @@ When you define a feature like this
 ```toml
 [features]
 default = []
-reload = ["dep:hot-lib-reloader"]
+reload = ["lib/reload", "dep:hot-lib-reloader"]
 
 [dependencies]
+lib = { path = "lib" }
 hot-lib-reloader = { version = "^0.6", optional = true }
 ```
 
@@ -283,13 +284,13 @@ use lib::*;
 mod hot_lib { /*...*/ }
 ```
 
-To run the static version just use `cargo run` the hot reloadable variant with `cargo run --features reload`.
-
-
-### Disable `#[no-mangle]` in release mode
+You can also conditionally use `#[no_mangle]` in your library:
 
-To not pay a penalty for exposing functions using `#[no_mangle]` in release mode where everything is statically compiled (see previous tip) and no functions need to be exported, you can use the [no-mangle-if-debug attribute macro](./macro-no-mangle-if-debug). It will conditionally disable name mangling, depending on wether you build release or debug mode.
+```rust
+#[cfg_attr(feature = "reload", no_mangle)]
+```
 
+To run the static version just use `cargo run` the hot reloadable variant with `cargo run --features reload`.
 
 ### Use serialization or generic values for changing types
 

examples/reload-feature/Cargo.toml

@@ -15,4 +15,4 @@ log = "*"
 
 [features]
 default = []
-reload = ["dep:hot-lib-reloader"]
+reload = ["lib/reload", "dep:hot-lib-reloader"]

examples/reload-feature/lib/Cargo.toml

@@ -5,3 +5,7 @@ edition = "2021"
 
 [lib]
 crate-type = ["rlib", "dylib"]
+
+[features]
+default = []
+reload = []

examples/reload-feature/lib/src/lib.rs

@@ -1,4 +1,4 @@
-#[no_mangle]
+#[cfg_attr(feature = "reload", no_mangle)]
 pub fn do_stuff() {
     println!("step called");
 }

macro/src/util.rs

@@ -50,13 +50,49 @@ pub fn read_functions_from_file(
                 // we can optionally assume that the function will be unmangled
                 // by other means than a direct attribute
                 if !ignore_no_mangle {
-                    let no_mangle = fun
-                        .attrs
-                        .iter()
-                        .filter_map(|attr| attr.path.get_ident())
-                        .any(|ident| *ident == "no_mangle");
+                    fn cfg_no_mangle<'a>(
+                        mut cfg_items: impl Iterator<Item = &'a syn::NestedMeta>,
+                    ) -> bool {
+                        let _predicate = cfg_items.next();
+                        // TODO: return false if predicate is false
+                        // false positives are unlikely, but can still compile error
 
-                    if !no_mangle {
+                        cfg_items.any(|meta| {
+                            let meta = match meta {
+                                syn::NestedMeta::Meta(m) => m,
+                                _ => return false,
+                            };
+                            match meta {
+                                syn::Meta::Path(path) => path.is_ident("no_mangle"),
+                                syn::Meta::List(m) => cfg_no_mangle(m.nested.iter()),
+                                _ => false,
+                            }
+                        })
+                    }
+
+                    fn is_no_mangle<'a>(
+                        mut attrs: impl Iterator<Item = &'a syn::Attribute>,
+                    ) -> bool {
+                        attrs.any(|attr| {
+                            let ident = match attr.path.get_ident() {
+                                Some(i) => i,
+                                None => return false,
+                            };
+                            if *ident == "no_mangle" {
+                                true
+                            } else if *ident == "cfg_attr" {
+                                let nested = match attr.parse_meta() {
+                                    Ok(syn::Meta::List(m)) => m.nested,
+                                    _ => return false,
+                                };
+                                cfg_no_mangle(nested.iter())
+                            } else {
+                                false
+                            }
+                        })
+                    }
+
+                    if !is_no_mangle(fun.attrs.iter()) {
                         continue;
                     };
                 }