Merge branch 'master' into drop-deprecated

Author: filmor

rustler/Cargo.toml

@@ -13,7 +13,6 @@ rust-version = "1.70"
 big_integer = ["dep:num-bigint"]
 default = ["nif_version_2_15"]
 derive = []
-alternative_nif_init_name = []
 allocator = []
 nif_version_2_14 = []
 nif_version_2_15 = ["nif_version_2_14"]

rustler/src/env.rs

@@ -48,6 +48,7 @@ pub struct SendError;
 
 impl<'a> Env<'a> {
     #[doc(hidden)]
+    #[inline]
     pub(crate) unsafe fn new_internal<T>(
         _lifetime_marker: &'a T,
         env: NIF_ENV,
@@ -69,11 +70,13 @@ impl<'a> Env<'a> {
     ///
     /// # Unsafe
     /// Don't create multiple `Env`s with the same lifetime.
+    #[inline]
     pub unsafe fn new<T>(_lifetime_marker: &'a T, env: NIF_ENV) -> Env<'a> {
         Self::new_internal(_lifetime_marker, env, EnvKind::ProcessBound)
     }
 
     #[doc(hidden)]
+    #[inline]
     pub unsafe fn new_init_env<T>(_lifetime_marker: &'a T, env: NIF_ENV) -> Env<'a> {
         Self::new_internal(_lifetime_marker, env, EnvKind::Init)
     }
@@ -83,6 +86,7 @@ impl<'a> Env<'a> {
     }
 
     /// Convenience method for building a tuple `{error, Reason}`.
+    #[inline]
     pub fn error_tuple(self, reason: impl Encoder) -> Term<'a> {
         let error = crate::types::atom::error().to_term(self);
         (error, reason).encode(self)
@@ -101,6 +105,7 @@ impl<'a> Env<'a> {
     ///
     /// The result indicates whether the send was successful, see also
     /// [enif\_send](https://www.erlang.org/doc/man/erl_nif.html#enif_send).
+    #[inline]
     pub fn send(self, pid: &LocalPid, message: impl Encoder) -> Result<(), SendError> {
         let env = if is_scheduler_thread() {
             if self.kind == EnvKind::ProcessIndependent {

rustler/src/lib.rs

@@ -30,6 +30,7 @@ pub mod wrapper;
 pub mod codegen_runtime;
 
 mod alloc;
+pub use crate::alloc::EnifAllocator;
 
 #[macro_use]
 pub mod types;

rustler/src/serde/util.rs

@@ -28,7 +28,7 @@ pub fn parse_bool(term: &Term) -> Result<bool, Error> {
     }
 }
 
-pub fn parse_binary(term: Term) -> Result<&[u8], Error> {
+pub fn parse_binary<'a>(term: Term<'a>) -> Result<&'a [u8], Error> {
     validate_binary(&term)?;
     let binary: Binary = term.decode().or(Err(Error::ExpectedBinary))?;
     Ok(binary.as_slice())
@@ -42,7 +42,7 @@ pub fn parse_number<'a, T: Decoder<'a>>(term: &Term<'a>) -> Result<T, Error> {
     term.decode().or(Err(Error::ExpectedNumber))
 }
 
-pub fn parse_str(term: Term) -> Result<&str, Error> {
+pub fn parse_str<'a>(term: Term<'a>) -> Result<&'a str, Error> {
     let bytes = parse_binary(term)?;
     std::str::from_utf8(bytes).or(Err(Error::ExpectedStringable))
 }

rustler/src/sys/nif_filler.rs

@@ -2,11 +2,6 @@ pub(crate) trait DynNifFiller {
     fn write<T: Copy>(&self, field: &mut Option<T>, name: &str);
 }
 
-pub struct NullNifFiller;
-impl DynNifFiller for NullNifFiller {
-    fn write<T: Copy>(&self, _field: &mut Option<T>, _name: &str) {}
-}
-
 #[cfg(not(target_os = "windows"))]
 mod internal {
     use std::ffi::OsStr;
@@ -43,6 +38,11 @@ mod internal {
 mod internal {
     use super::*;
 
+    pub struct NullNifFiller;
+    impl DynNifFiller for NullNifFiller {
+        fn write<T: Copy>(&self, _field: &mut Option<T>, _name: &str) {}
+    }
+
     pub fn new() -> impl DynNifFiller {
         NullNifFiller
     }

rustler/src/term.rs

@@ -29,15 +29,18 @@ impl<'a> Term<'a> {
     /// # Unsafe
     /// The caller must ensure that `env` is the environment that `inner` belongs to,
     /// unless `inner` is an atom term.
+    #[inline]
     pub unsafe fn new(env: Env<'a>, inner: NIF_TERM) -> Self {
         Term { term: inner, env }
     }
     /// This extracts the raw term pointer. It is usually used in order to obtain a type that can
     /// be passed to calls into the erlang vm.
+    #[inline]
     pub fn as_c_arg(&self) -> NIF_TERM {
         self.term
     }
 
+    #[inline]
     pub fn get_env(self) -> Env<'a> {
         self.env
     }
@@ -46,6 +49,7 @@ impl<'a> Term<'a> {
     ///
     /// If the term is already is in the provided env, it will be directly returned. Otherwise
     /// the term will be copied over.
+    #[inline]
     pub fn in_env<'b>(&self, env: Env<'b>) -> Term<'b> {
         if self.get_env() == env {
             // It's safe to create a new Term<'b> without copying because we
@@ -81,13 +85,15 @@ impl<'a> Term<'a> {
     /// is needed.
     ///
     /// [`decode`]: #method.decode
+    #[inline]
     pub fn decode_as_binary(self) -> NifResult<Binary<'a>> {
         if self.is_binary() {
             return Binary::from_term(self);
         }
         Binary::from_iolist(self)
     }
 
+    #[inline]
     pub fn to_binary(self) -> OwnedBinary {
         let raw_binary = unsafe { term_to_binary(self.env.as_c_arg(), self.as_c_arg()) }.unwrap();
         unsafe { OwnedBinary::from_raw(raw_binary) }

rustler/src/types/binary.rs

@@ -248,6 +248,7 @@ pub struct Binary<'a> {
 
 impl<'a> Binary<'a> {
     /// Consumes `owned` and returns an immutable `Binary`.
+    #[inline]
     pub fn from_owned(owned: OwnedBinary, env: Env<'a>) -> Self {
         // We are transferring ownership of `owned`'s data to the
         // environment. Therefore, we need to prevent `owned`'s destructor being
@@ -269,6 +270,7 @@ impl<'a> Binary<'a> {
     ///
     /// If allocation fails, an error will be returned.
     #[allow(clippy::wrong_self_convention)]
+    #[inline]
     pub fn to_owned(&self) -> Option<OwnedBinary> {
         OwnedBinary::from_unowned(self)
     }
@@ -278,6 +280,7 @@ impl<'a> Binary<'a> {
     /// # Errors
     ///
     /// If `term` is not a binary, an error will be returned.
+    #[inline]
     pub fn from_term(term: Term<'a>) -> Result<Self, Error> {
         let mut binary = MaybeUninit::uninit();
         if unsafe {
@@ -315,6 +318,7 @@ impl<'a> Binary<'a> {
     /// # Errors
     ///
     /// If `term` is not an `iolist`, an error will be returned.
+    #[inline]
     pub fn from_iolist(term: Term<'a>) -> Result<Self, Error> {
         let mut binary = MaybeUninit::uninit();
         if unsafe {
@@ -338,11 +342,13 @@ impl<'a> Binary<'a> {
 
     /// Returns an Erlang term representation of `self`.
     #[allow(clippy::wrong_self_convention)]
+    #[inline]
     pub fn to_term<'b>(&self, env: Env<'b>) -> Term<'b> {
         self.term.in_env(env)
     }
 
     /// Extracts a slice containing the entire binary.
+    #[inline]
     pub fn as_slice(&self) -> &'a [u8] {
         unsafe { ::std::slice::from_raw_parts(self.buf, self.size) }
     }
@@ -355,6 +361,7 @@ impl<'a> Binary<'a> {
     /// # Errors
     ///
     /// If `offset + length` is out of bounds, an error will be returned.
+    #[inline]
     pub fn make_subbinary(&self, offset: usize, length: usize) -> NifResult<Binary<'a>> {
         let min_len = length.checked_add(offset);
         if min_len.ok_or(Error::BadArg)? > self.size {
@@ -452,40 +459,47 @@ pub struct NewBinary<'a> {
 
 impl<'a> NewBinary<'a> {
     /// Allocates a new `NewBinary`
+    #[inline]
     pub fn new(env: Env<'a>, size: usize) -> Self {
         let (buf, term) = unsafe { new_binary(env, size) };
         NewBinary { buf, term, size }
     }
     /// Extracts a slice containing the entire binary.
+    #[inline]
     pub fn as_slice(&self) -> &[u8] {
         unsafe { ::std::slice::from_raw_parts(self.buf, self.size) }
     }
 
     /// Extracts a mutable slice of the entire binary.
+    #[inline]
     pub fn as_mut_slice(&mut self) -> &mut [u8] {
         unsafe { ::std::slice::from_raw_parts_mut(self.buf, self.size) }
     }
 }
 
 impl<'a> From<NewBinary<'a>> for Binary<'a> {
+    #[inline]
     fn from(new_binary: NewBinary<'a>) -> Self {
         Binary::from_term(new_binary.term).unwrap()
     }
 }
 
 impl<'a> From<NewBinary<'a>> for Term<'a> {
+    #[inline]
     fn from(new_binary: NewBinary<'a>) -> Self {
         new_binary.term
     }
 }
 
 impl Deref for NewBinary<'_> {
     type Target = [u8];
+    #[inline]
     fn deref(&self) -> &[u8] {
         self.as_slice()
     }
 }
 impl DerefMut for NewBinary<'_> {
+    #[inline]
     fn deref_mut(&mut self) -> &mut [u8] {
         self.as_mut_slice()
     }

rustler/src/types/list.rs

@@ -56,6 +56,7 @@ impl<'a> ListIterator<'a> {
 impl<'a> Iterator for ListIterator<'a> {
     type Item = Term<'a>;
 
+    #[inline]
     fn next(&mut self) -> Option<Term<'a>> {
         let env = self.term.get_env();
         let cell = unsafe { list::get_list_cell(env.as_c_arg(), self.term.as_c_arg()) };
@@ -78,6 +79,7 @@ impl<'a> Iterator for ListIterator<'a> {
 }
 
 impl<'a> Decoder<'a> for ListIterator<'a> {
+    #[inline]
     fn decode(term: Term<'a>) -> NifResult<Self> {
         match ListIterator::new(term) {
             Some(iter) => Ok(iter),
@@ -96,6 +98,7 @@ impl<T> Encoder for Vec<T>
 where
     T: Encoder,
 {
+    #[inline]
     fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
         self.as_slice().encode(env)
     }
@@ -105,6 +108,7 @@ impl<'a, T> Decoder<'a> for Vec<T>
 where
     T: Decoder<'a>,
 {
+    #[inline]
     fn decode(term: Term<'a>) -> NifResult<Self> {
         let iter: ListIterator = term.decode()?;
         let res: NifResult<Self> = iter.map(|x| x.decode::<T>()).collect();
@@ -116,6 +120,7 @@ impl<T> Encoder for [T]
 where
     T: Encoder,
 {
+    #[inline]
     fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
         let term_array: Vec<NIF_TERM> = self.iter().map(|x| x.encode(env).as_c_arg()).collect();
         unsafe { Term::new(env, list::make_list(env.as_c_arg(), &term_array)) }
@@ -126,6 +131,7 @@ impl<T> Encoder for &[T]
 where
     T: Encoder,
 {
+    #[inline]
     fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
         let term_array: Vec<NIF_TERM> = self.iter().map(|x| x.encode(env).as_c_arg()).collect();
         unsafe { Term::new(env, list::make_list(env.as_c_arg(), &term_array)) }
@@ -135,6 +141,7 @@ where
 /// ## List terms
 impl<'a> Term<'a> {
     /// Returns a new empty list.
+    #[inline]
     pub fn list_new_empty(env: Env<'a>) -> Term<'a> {
         let list: &[u8] = &[];
         list.encode(env)
@@ -144,6 +151,7 @@ impl<'a> Term<'a> {
     /// See documentation for ListIterator for more information.
     ///
     /// Returns None if the term is not a list.
+    #[inline]
     pub fn into_list_iterator(self) -> NifResult<ListIterator<'a>> {
         ListIterator::new(self).ok_or(Error::BadArg)
     }
@@ -156,6 +164,7 @@ impl<'a> Term<'a> {
     /// ```elixir
     /// length(self_term)
     /// ```
+    #[inline]
     pub fn list_length(self) -> NifResult<usize> {
         unsafe { list::get_list_length(self.get_env().as_c_arg(), self.as_c_arg()) }
             .ok_or(Error::BadArg)
@@ -171,6 +180,7 @@ impl<'a> Term<'a> {
     /// [head, tail] = self_term
     /// {head, tail}
     /// ```
+    #[inline]
     pub fn list_get_cell(self) -> NifResult<(Term<'a>, Term<'a>)> {
         let env = self.get_env();
         unsafe {
@@ -183,6 +193,7 @@ impl<'a> Term<'a> {
     /// Makes a copy of the self list term and reverses it.
     ///
     /// Returns Err(Error::BadArg) if the term is not a list.
+    #[inline]
     pub fn list_reverse(self) -> NifResult<Term<'a>> {
         let env = self.get_env();
         unsafe {

rustler/src/types/local_pid.rs

@@ -10,10 +10,12 @@ pub struct LocalPid {
 }
 
 impl LocalPid {
+    #[inline]
     pub fn as_c_arg(&self) -> &ErlNifPid {
         &self.c
     }
 
+    #[inline]
     pub fn from_c_arg(erl_nif_pid: ErlNifPid) -> Self {
         LocalPid { c: erl_nif_pid }
     }
@@ -25,6 +27,7 @@ impl LocalPid {
 }
 
 impl<'a> Decoder<'a> for LocalPid {
+    #[inline]
     fn decode(term: Term<'a>) -> NifResult<LocalPid> {
         unsafe { pid::get_local_pid(term.get_env().as_c_arg(), term.as_c_arg()) }
             .map(|pid| LocalPid { c: pid })
@@ -33,6 +36,7 @@ impl<'a> Decoder<'a> for LocalPid {
 }
 
 impl Encoder for LocalPid {
+    #[inline]
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
         unsafe { Term::new(env, pid::make_pid(env.as_c_arg(), self.c)) }
     }
@@ -67,6 +71,7 @@ impl Env<'_> {
     /// Panics if this environment is process-independent.  (The only way to get such an
     /// environment is to use `OwnedEnv`.  The `Env` that Rustler passes to NIFs when they're
     /// called is always associated with the calling Erlang process.)
+    #[inline]
     pub fn pid(self) -> LocalPid {
         let mut pid = MaybeUninit::uninit();
         if unsafe { enif_self(self.as_c_arg(), pid.as_mut_ptr()) }.is_null() {