Fix more tests, some renamings, move function to Env

rustler/src/lib.rs

@@ -39,10 +39,10 @@ mod wrapped_types;
 
 pub use crate::term::Term;
 pub use crate::types::{
-    Atom, Binary, Decoder, Encoder, ErlOption, LocalPid, NewBinary, OwnedBinary
+    Atom, Binary, Decoder, Encoder, ErlOption, LocalPid, NewBinary, OwnedBinary,
 };
 
-pub use crate::wrapped_types::{ListIterator, Reference, MapIterator, Map, Tuple};
+pub use crate::wrapped_types::{ListIterator, Map, MapIterator, Reference, Tuple};
 
 #[cfg(feature = "big_integer")]
 pub use crate::types::BigInt;

rustler/src/serde/ser.rs

@@ -2,7 +2,7 @@ use std::io::Write;
 
 use crate::serde::{atoms, error::Error, util};
 use crate::wrapper::list::make_list;
-use crate::{Encoder, Env, OwnedBinary, Term, Tuple};
+use crate::{Encoder, Env, OwnedBinary, Term};
 use serde::ser::{self, Serialize};
 
 #[inline]
@@ -336,7 +336,7 @@ impl<'a> SequenceSerializer<'a> {
 
     #[inline]
     fn to_tuple(&self) -> Result<Term<'a>, Error> {
-        Ok(Tuple::make(self.ser.env, &self.items))
+        Ok(self.ser.env.make_tuple(&self.items).into())
     }
 }
 

rustler/src/wrapped_types/list.rs

@@ -103,7 +103,7 @@ where
     }
 }
 
-impl<'a, T> Encoder for &'a [T]
+impl<T> Encoder for &[T]
 where
     T: Encoder,
 {
@@ -131,7 +131,7 @@ impl<'a> ListIterator<'a> {
         Some(len as usize)
     }
 
-    pub fn empty(&self) -> bool {
+    pub fn is_empty(&self) -> bool {
         self.is_empty_list()
     }
 

rustler/src/wrapped_types/reference.rs

@@ -4,7 +4,7 @@ use crate::sys::enif_make_ref;
 
 use super::wrapper;
 
-wrapper!{
+wrapper! {
     struct Reference(TermType::Ref)
 }
 

rustler/src/wrapped_types/tuple.rs

@@ -9,7 +9,7 @@ wrapper!(
     struct Tuple(TermType::Tuple)
 );
 
-pub unsafe fn get_tuple<'a>(term: Term<'a>) -> NifResult<&'a [ERL_NIF_TERM]> {
+pub unsafe fn get_tuple(term: Term<'_>) -> NifResult<&[ERL_NIF_TERM]> {
     let env = term.get_env();
     let mut arity: c_int = 0;
     let mut array_ptr = MaybeUninit::uninit();
@@ -27,11 +27,11 @@ pub unsafe fn get_tuple<'a>(term: Term<'a>) -> NifResult<&'a [ERL_NIF_TERM]> {
 }
 
 impl<'a> Tuple<'a> {
-    pub fn make(env: Env<'a>, terms: &[Term<'a>]) -> Term<'a> {
-        make_tuple(env, terms)
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
-    pub fn size(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.get_elements().len()
     }
 
@@ -58,16 +58,21 @@ impl<'a> Tuple<'a> {
     }
 }
 
+impl<'a> Env<'a> {
+    pub fn make_tuple(&self, terms: &[Term<'a>]) -> Tuple<'a> {
+        make_tuple(*self, terms)
+    }
+}
+
 /// Convert a vector of terms to an Erlang tuple. (To convert from a Rust tuple to an Erlang tuple,
 /// use `Encoder` instead.)
-pub fn make_tuple<'a>(env: Env<'a>, terms: &[Term]) -> Term<'a> {
+pub fn make_tuple<'a>(env: Env<'a>, terms: &[Term]) -> Tuple<'a> {
     let c_terms: Vec<ERL_NIF_TERM> = terms.iter().map(|term| term.as_c_arg()).collect();
     unsafe {
         let term =
             enif_make_tuple_from_array(env.as_c_arg(), c_terms.as_ptr(), c_terms.len() as u32);
-        Term::new(env, term)
+        Term::new(env, term).try_into().unwrap()
     }
-    // unsafe { Term::new(env, tuple::make_tuple(env.as_c_arg(), &c_terms)) }
 }
 
 /// Helper macro to emit tuple-like syntax. Wraps its arguments in parentheses, and adds a comma if
@@ -94,7 +99,7 @@ macro_rules! impl_nifencoder_nifdecoder_for_tuple {
         {
             fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
                 let arr = [ $( Encoder::encode(&self.$index, env) ),* ];
-                make_tuple(env, &arr)
+                make_tuple(env, &arr).into()
             }
         }
 

rustler_codegen/src/encode_decode_templates.rs

@@ -153,7 +153,7 @@ pub(crate) fn encoder(ctx: &Context, inner: TokenStream) -> TokenStream {
         impl #impl_generics ::rustler::Encoder for #ident #ty_generics #where_clause {
             #[allow(clippy::needless_borrow)]
             fn encode<'__rustler__encode_lifetime>(&self, env: ::rustler::Env<'__rustler__encode_lifetime>) -> ::rustler::Term<'__rustler__encode_lifetime> {
-                #inner
+                #inner.into()
             }
         }
     }

rustler_codegen/src/record.rs

@@ -103,7 +103,7 @@ fn gen_decoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
         quote! {
             use #atoms_module_name::*;
 
-            let terms = match ::rustler::types::tuple::get_tuple(term) {
+            let terms = match ::rustler::Tuple::try_from(term) {
                 Err(_) => return Err(::rustler::Error::RaiseTerm(
                         Box::new(format!("Invalid Record structure for {}", #struct_name_str)))),
                 Ok(value) => value,
@@ -113,19 +113,24 @@ fn gen_decoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
                 return Err(::rustler::Error::RaiseAtom("invalid_record"));
             }
 
-            let tag : ::rustler::types::atom::Atom = terms[0].decode()?;
+            let tag : ::rustler::types::atom::Atom = terms.get(0).unwrap().decode()?;
 
             if tag != atom_tag() {
                 return Err(::rustler::Error::RaiseAtom("invalid_record"));
             }
 
-            fn try_decode_index<'a, T>(terms: &[::rustler::Term<'a>], pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
+            fn try_decode_index<'a, T>(terms: &::rustler::Tuple<'a>, pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
                 where
                     T: rustler::Decoder<'a>,
             {
-                match ::rustler::Decoder::decode(terms[index]) {
+                use ::rustler::{Decoder, Error};
+
+                let term = terms.get(index).ok_or_else(|| Error::BadArg)?;
+
+                match term.decode() {
                     Err(_) => Err(::rustler::Error::RaiseTerm(Box::new(
-                                format!("Could not decode field {} on Record {}", pos_in_struct, #struct_name_str)))),
+                        format!("Could not decode field {} on Record {}", pos_in_struct, #struct_name_str))
+                    )),
                     Ok(value) => Ok(value)
                 }
             }
@@ -166,7 +171,7 @@ fn gen_encoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
 
             use ::rustler::Encoder;
             let arr = #field_list_ast;
-            ::rustler::types::tuple::make_tuple(env, &arr)
+            env.make_tuple(&arr)
         },
     )
 }

rustler_codegen/src/tagged_enum.rs

@@ -141,10 +141,10 @@ fn gen_decoder(ctx: &Context, variants: &[&Variant], atoms_module_name: &Ident)
 
             if let Ok(unit) = ::rustler::types::atom::Atom::from_term(term) {
                 #(#unit_decoders)*
-            } else if let Ok(tuple) = ::rustler::types::tuple::get_tuple(term) {
+            } else if let Ok(tuple) = ::rustler::Tuple::try_from(term) {
                 let name = tuple
                             .get(0)
-                            .and_then(|&first| ::rustler::types::atom::Atom::from_term(first).ok())
+                            .and_then(|first| ::rustler::types::atom::Atom::from_term(first).ok())
                             .ok_or(::rustler::Error::RaiseAtom("invalid_variant"))?;
                 #(#named_unnamed_decoders)*
             }
@@ -208,7 +208,7 @@ fn gen_unnamed_decoder<'a>(
             let i = i + 1;
             let ty = &f.ty;
             quote! {
-                <#ty as ::rustler::Decoder>::decode(tuple[#i]).map_err(|_| ::rustler::Error::RaiseTerm(
+                <#ty as ::rustler::Decoder>::decode(tuple.get(#i).unwrap()).map_err(|_| ::rustler::Error::RaiseTerm(
                     Box::new(format!("Could not decode field on position {}", #i))
                 ))?
             }
@@ -250,7 +250,7 @@ fn gen_named_decoder(
             let enum_name_string = enum_name.to_string();
 
             let assignment = quote_spanned! { field.span() =>
-                let #variable = try_decode_field(tuple[1], #atom_fun()).map_err(|_|{
+                let #variable = try_decode_field(tuple.get(1).unwrap(), #atom_fun()).map_err(|_|{
                     ::rustler::Error::RaiseTerm(Box::new(format!(
                         "Could not decode field '{}' on Enum '{}'",
                         #ident_string, #enum_name_string
@@ -267,7 +267,7 @@ fn gen_named_decoder(
 
     quote! {
         if tuple.len() == 2 && name == #atom_fn() {
-            let len = tuple[1].map_size().map_err(|_| ::rustler::Error::RaiseTerm(Box::new(
+            let len = tuple.get(1).unwrap().map_size().map_err(|_| ::rustler::Error::RaiseTerm(Box::new(
                 "The second element of the tuple must be a map"
             )))?;
             #(#assignments)*
@@ -334,7 +334,7 @@ fn gen_named_encoder(
         } => {
             let map = ::rustler::Term::map_from_term_arrays(env, &[#(#keys),*], &[#(#values),*])
                 .expect("Failed to create map");
-            ::rustler::types::tuple::make_tuple(env, &[::rustler::Encoder::encode(&#atom_fn(), env), map])
+            env.make_tuple(&[::rustler::Encoder::encode(&#atom_fn(), env), map]).into()
         }
     }
 }

rustler_codegen/src/tuple.rs

@@ -84,18 +84,22 @@ fn gen_decoder(ctx: &Context, fields: &[&Field]) -> TokenStream {
     super::encode_decode_templates::decoder(
         ctx,
         quote! {
-                let terms = ::rustler::types::tuple::get_tuple(term)?;
+                let terms = ::rustler::Tuple::try_from(term)?;
                 if terms.len() != #field_num {
                     return Err(::rustler::Error::BadArg);
                 }
 
-                fn try_decode_index<'a, T>(terms: &[::rustler::Term<'a>], pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
+                fn try_decode_index<'a, T>(terms: &::rustler::Tuple<'a>, pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
                     where
                         T: rustler::Decoder<'a>,
                 {
-                    match ::rustler::Decoder::decode(terms[index]) {
-                        Err(_) => Err(::rustler::Error::RaiseTerm(Box::new(
-                                    format!("Could not decode field {} on {}", pos_in_struct, #struct_name_str)))),
+                    use ::rustler::{Decoder, Error};
+
+                    let term = terms.get(index).ok_or_else(|| Error::BadArg)?;
+                    match term.decode() {
+                        Err(_) => Err(Error::RaiseTerm(Box::new(
+                            format!("Could not decode field {} on {}", pos_in_struct, #struct_name_str))
+                        )),
                         Ok(value) => Ok(value)
                     }
                 }
@@ -131,7 +135,7 @@ fn gen_encoder(ctx: &Context, fields: &[&Field]) -> TokenStream {
         quote! {
             use ::rustler::Encoder;
             let arr = #field_list_ast;
-            ::rustler::types::tuple::make_tuple(env, &arr)
+            env.make_tuple(&arr)
         },
     )
 }

rustler_tests/native/rustler_serde_test/src/lib.rs

@@ -11,7 +11,7 @@ mod types;
 
 use crate::types::Animal;
 use rustler::serde::{atoms, Deserializer, Error, Serializer};
-use rustler::{types::tuple, Encoder, Env, NifResult, SerdeTerm, Term};
+use rustler::{Encoder, Env, NifResult, SerdeTerm, Term};
 
 init!("Elixir.SerdeRustlerTests");
 
@@ -56,10 +56,10 @@ where
 
 fn ok_tuple<'a>(env: Env<'a>, term: Term<'a>) -> Term<'a> {
     let ok_atom_term = atoms::ok().encode(env);
-    tuple::make_tuple(env, &[ok_atom_term, term])
+    env.make_tuple(&[ok_atom_term, term]).into()
 }
 
 fn error_tuple<'a>(env: Env<'a>, reason_term: Term<'a>) -> Term<'a> {
     let err_atom_term = atoms::error().encode(env);
-    tuple::make_tuple(env, &[err_atom_term, reason_term])
+    env.make_tuple(&[err_atom_term, reason_term]).into()
 }

rustler_tests/native/rustler_test/src/test_env.rs

@@ -1,8 +1,7 @@
 use rustler::env::{OwnedEnv, SavedTerm, SendError};
 use rustler::types::atom;
-use rustler::types::list::ListIterator;
 use rustler::types::LocalPid;
-use rustler::{Atom, Encoder, Env, NifResult, Reference, Term};
+use rustler::{Atom, Encoder, Env, ListIterator, NifResult, Reference, Term};
 use std::thread;
 
 // Send a message to several PIDs.

rustler_tests/native/rustler_test/src/test_map.rs

@@ -1,6 +1,4 @@
-use rustler::types::map::MapIterator;
-use rustler::types::tuple::make_tuple;
-use rustler::{Encoder, Env, Error, ListIterator, NifResult, Term};
+use rustler::{Encoder, Env, Error, ListIterator, MapIterator, NifResult, Term, Tuple};
 
 #[rustler::nif]
 pub fn sum_map_values(iter: MapIterator) -> NifResult<i64> {
@@ -11,31 +9,31 @@ pub fn sum_map_values(iter: MapIterator) -> NifResult<i64> {
 }
 
 #[rustler::nif]
-pub fn map_entries<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Term<'a>>> {
+pub fn map_entries<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Tuple<'a>>> {
     let mut vec = vec![];
     for (key, value) in iter {
         let key_string = key.decode::<String>()?;
         vec.push((key_string, value));
     }
 
-    let erlang_pairs: Vec<Term> = vec
+    let erlang_pairs: Vec<_> = vec
         .into_iter()
-        .map(|(key, value)| make_tuple(env, &[key.encode(env), value]))
+        .map(|(key, value)| env.make_tuple(&[key.encode(env), value]))
         .collect();
     Ok(erlang_pairs)
 }
 
 #[rustler::nif]
-pub fn map_entries_reversed<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Term<'a>>> {
+pub fn map_entries_reversed<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Tuple<'a>>> {
     let mut vec = vec![];
     for (key, value) in iter.rev() {
         let key_string = key.decode::<String>()?;
         vec.push((key_string, value));
     }
 
-    let erlang_pairs: Vec<Term> = vec
+    let erlang_pairs: Vec<_> = vec
         .into_iter()
-        .map(|(key, value)| make_tuple(env, &[key.encode(env), value]))
+        .map(|(key, value)| env.make_tuple(&[key.encode(env), value]))
         .collect();
     Ok(erlang_pairs)
 }