Merge pull request #613 from filmor/discovery

Discover NIFs at startup

Author: filmor

CHANGELOG.md

@@ -8,6 +8,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 See [`UPGRADE.md`](./UPGRADE.md) for additional help when upgrading to newer
 versions.
 
+## [unreleased]
+
+### Added
+
+### Fixed
+
+### Changed
+
+- NIF implementations are now discovered automatically and the respective
+  argument of `rustler::init!` is ignored (#613)
+
+### Removed
+
+
 ## [0.33.0] - 2024-05-29
 
 ### Added

README.md

@@ -55,7 +55,7 @@ fn add(a: i64, b: i64) -> i64 {
     a + b
 }
 
-rustler::init!("Elixir.Math", [add]);
+rustler::init!("Elixir.Math");
 ```
 
 #### Minimal Supported Rust Version (MSRV)

UPGRADE.md

@@ -2,6 +2,12 @@
 
 This document is intended to simplify upgrading to newer versions by extending the changelog.
 
+## 0.33 -> 0.34
+
+1. NIF implementations are now discovered automatically, the respective argument
+   in the `rustler::init!` macro should be removed. If a NIF implementation
+   should not be exported, it must be disabled with a `#[cfg]` marker.
+
 ## 0.32 -> 0.33
 
 The macro changes that where already carried out in version `0.22` are now
@@ -109,7 +115,7 @@ rustler::rustler_export_nifs! {
     "Elixir.Math",
     [
         ("add", 2, add),
-	("long_running_operation", 0, long_running_operation, SchedulerFlags::DirtyCpu)
+        ("long_running_operation", 0, long_running_operation, SchedulerFlags::DirtyCpu)
     ],
     None
 }
@@ -184,9 +190,9 @@ NIF called `_long_running_operation`, which used to be declared prior to Rustler
 rustler::rustler_export_nifs! {
     "Elixir.SomeNif",
     [
-	// Note that the function in Rust is long_running_operation, but the NIF is exported as
-	// _long_running_operation!
-	("_long_running_operation", 0, long_running_operation, SchedulerFlags::DirtyCpu)
+        // Note that the function in Rust is long_running_operation, but the NIF is exported as
+        // _long_running_operation!
+        ("_long_running_operation", 0, long_running_operation, SchedulerFlags::DirtyCpu)
     ],
     None
 }

rustler/Cargo.toml

@@ -22,6 +22,7 @@ nif_version_2_17 = ["nif_version_2_16", "rustler_sys/nif_version_2_17"]
 serde = ["dep:serde"]
 
 [dependencies]
+inventory = "0.3"
 rustler_codegen = { path = "../rustler_codegen", version = "0.33.0", optional = true}
 rustler_sys = { path = "../rustler_sys", version = "~2.4.1" }
 num-bigint = { version = "0.4", optional = true }

rustler/src/codegen_runtime.rs

@@ -5,6 +5,9 @@ use std::fmt;
 
 use crate::{Encoder, Env, OwnedBinary, Term};
 
+// Re-export of inventory
+pub use inventory;
+
 // Names used by the `rustler::init!` macro or other generated code.
 pub use crate::wrapper::exception::raise_exception;
 pub use crate::wrapper::{

rustler/src/nif.rs

@@ -1,13 +1,25 @@
 use crate::codegen_runtime::{c_char, c_int, c_uint, DEF_NIF_FUNC, NIF_ENV, NIF_TERM};
 
-pub trait Nif {
-    const NAME: *const c_char;
-    const ARITY: c_uint;
-    const FLAGS: c_uint;
-    const FUNC: DEF_NIF_FUNC;
-    const RAW_FUNC: unsafe extern "C" fn(
-        nif_env: NIF_ENV,
-        argc: c_int,
-        argv: *const NIF_TERM,
-    ) -> NIF_TERM;
+pub struct Nif {
+    pub name: *const c_char,
+    pub arity: c_uint,
+    pub flags: c_uint,
+    // pub func: DEF_NIF_FUNC,
+    pub raw_func:
+        unsafe extern "C" fn(nif_env: NIF_ENV, argc: c_int, argv: *const NIF_TERM) -> NIF_TERM,
 }
+
+impl Nif {
+    pub fn get_def(&self) -> DEF_NIF_FUNC {
+        DEF_NIF_FUNC {
+            arity: self.arity,
+            flags: self.flags,
+            function: self.raw_func,
+            name: self.name,
+        }
+    }
+}
+
+unsafe impl Sync for Nif {}
+
+inventory::collect!(Nif);

rustler/src/serde/mod.rs

@@ -12,7 +12,7 @@ in a better way and allow more Erlang-y configurations).
 use rustler::{self, Encoder, SerdeTerm};
 use serde::{Serialize, Deserialize};
 
-rustler::init!("Elixir.SerdeNif", [readme]);
+rustler::init!("Elixir.SerdeNif");
 
 // NOTE: to serialize to the correct Elixir record, you MUST tell serde to
 // rename the variants to the full Elixir record module atom.

rustler_benchmarks/native/benchmark/src/lib.rs

@@ -2,19 +2,4 @@ mod nif_record;
 mod nif_struct;
 mod nif_various;
 
-rustler::init!(
-    "Elixir.Benchmark",
-    [
-        nif_struct::benchmark,
-        nif_record::benchmark,
-        nif_various::encode_tagged_enum,
-        nif_various::decode_tagged_enum,
-        nif_various::decode_struct,
-        nif_various::decode_struct_string,
-        nif_various::decode_string,
-        nif_various::decode_term,
-        nif_various::void,
-        nif_various::encode_atom,
-        nif_various::compare_atom
-    ]
-);
+rustler::init!("Elixir.Benchmark");

rustler_codegen/Cargo.toml

@@ -17,6 +17,7 @@ syn = { version = "2.0", features = ["full", "extra-traits"] }
 quote = "1.0"
 heck = "0.5"
 proc-macro2 = "1.0"
+inventory = "0.3"
 
 [dev-dependencies]
 trybuild = "1.0"

rustler_codegen/src/init.rs

@@ -1,26 +1,51 @@
 use proc_macro2::{Span, TokenStream};
-use quote::quote;
+use quote::{quote, quote_spanned};
 use syn::parse::{Parse, ParseStream};
-use syn::punctuated::Punctuated;
-use syn::token::Comma;
-use syn::{Expr, Ident, Result, Token};
+use syn::spanned::Spanned;
+use syn::{Ident, Result, Token};
 
 #[derive(Debug)]
 pub struct InitMacroInput {
     name: syn::Lit,
-    funcs: syn::ExprArray,
     load: TokenStream,
+    maybe_warning: TokenStream,
 }
 
 impl Parse for InitMacroInput {
     fn parse(input: ParseStream) -> Result<Self> {
         let name = syn::Lit::parse(input)?;
-        let _comma = <syn::Token![,]>::parse(input)?;
-        let funcs = syn::ExprArray::parse(input)?;
+
+        let maybe_warning = if input.peek(syn::token::Comma) && input.peek2(syn::token::Bracket) {
+            // peeked, must be there
+            let _ = syn::token::Comma::parse(input).unwrap();
+            if let Ok(funcs) = syn::ExprArray::parse(input) {
+                quote_spanned!(funcs.span() =>
+                    #[allow(dead_code)]
+                    fn rustler_init() {
+                        #[deprecated(
+                            since = "0.34.0",
+                            note = "Passing NIF functions explicitly is deprecated and this argument is ignored, please remove it"
+                        )]
+                        #[allow(non_upper_case_globals)]
+                        const explicit_nif_functions: () = ();
+                        let _ = explicit_nif_functions;
+                    }
+                )
+            } else {
+                quote!()
+            }
+        } else {
+            quote!()
+        };
+
         let options = parse_expr_assigns(input);
         let load = extract_option(options, "load");
 
-        Ok(InitMacroInput { name, funcs, load })
+        Ok(InitMacroInput {
+            name,
+            load,
+            maybe_warning,
+        })
     }
 }
 
@@ -55,20 +80,22 @@ fn extract_option(args: Vec<syn::ExprAssign>, name: &str) -> TokenStream {
 impl From<InitMacroInput> for proc_macro2::TokenStream {
     fn from(input: InitMacroInput) -> Self {
         let name = input.name;
-        let num_of_funcs = input.funcs.elems.len();
-        let funcs = nif_funcs(input.funcs.elems);
         let load = input.load;
+        let maybe_warning = input.maybe_warning;
 
         let inner = quote! {
             static mut NIF_ENTRY: Option<rustler::codegen_runtime::DEF_NIF_ENTRY> = None;
-            use rustler::Nif;
+            let nif_funcs: Box<[_]> =
+                rustler::codegen_runtime::inventory::iter::<rustler::Nif>()
+                .map(rustler::Nif::get_def)
+                .collect();
 
             let entry = rustler::codegen_runtime::DEF_NIF_ENTRY {
                 major: rustler::codegen_runtime::NIF_MAJOR_VERSION,
                 minor: rustler::codegen_runtime::NIF_MINOR_VERSION,
                 name: concat!(#name, "\0").as_ptr() as *const rustler::codegen_runtime::c_char,
-                num_of_funcs: #num_of_funcs as rustler::codegen_runtime::c_int,
-                funcs: [#funcs].as_ptr(),
+                num_of_funcs: nif_funcs.len() as rustler::codegen_runtime::c_int,
+                funcs: nif_funcs.as_ptr(),
                 load: {
                     extern "C" fn nif_load(
                         env: rustler::codegen_runtime::NIF_ENV,
@@ -91,12 +118,17 @@ impl From<InitMacroInput> for proc_macro2::TokenStream {
             };
 
             unsafe {
+                // Leak nif_funcs
+                std::mem::forget(nif_funcs);
+
                 NIF_ENTRY = Some(entry);
                 NIF_ENTRY.as_ref().unwrap()
             }
         };
 
         quote! {
+            #maybe_warning
+
             #[cfg(unix)]
             #[no_mangle]
             extern "C" fn nif_init() -> *const rustler::codegen_runtime::DEF_NIF_ENTRY {
@@ -115,17 +147,3 @@ impl From<InitMacroInput> for proc_macro2::TokenStream {
         }
     }
 }
-
-fn nif_funcs(funcs: Punctuated<Expr, Comma>) -> TokenStream {
-    let mut tokens = TokenStream::new();
-
-    for func in funcs.iter() {
-        if let Expr::Path(_) = *func {
-            tokens.extend(quote!(#func::FUNC,));
-        } else {
-            panic!("Expected an expression, found: {}", stringify!(func));
-        }
-    }
-
-    tokens
-}