Skip to content

Commit 62878f8

Browse files
filmorfilmor
committed
Fix more tests, some renamings, move function to Env
1 parent f43e09d commit 62878f8

File tree

12 files changed

+59
-48
lines changed

12 files changed

+59
-48
lines changed

‎rustler/src/lib.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,10 +39,10 @@ mod wrapped_types;
3939

4040
pub use crate::term::Term;
4141
pub use crate::types::{
42-
Atom, Binary, Decoder, Encoder, ErlOption, LocalPid, NewBinary, OwnedBinary
42+
Atom, Binary, Decoder, Encoder, ErlOption, LocalPid, NewBinary, OwnedBinary,
4343
};
4444

45-
pub use crate::wrapped_types::{ListIterator, Reference, MapIterator, Map, Tuple};
45+
pub use crate::wrapped_types::{ListIterator, Map, MapIterator, Reference, Tuple};
4646

4747
#[cfg(feature = "big_integer")]
4848
pub use crate::types::BigInt;

‎rustler/src/serde/ser.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use std::io::Write;
22

33
use crate::serde::{atoms, error::Error, util};
44
use crate::wrapper::list::make_list;
5-
use crate::{Encoder, Env, OwnedBinary, Term, Tuple};
5+
use crate::{Encoder, Env, OwnedBinary, Term};
66
use serde::ser::{self, Serialize};
77

88
#[inline]
@@ -336,7 +336,7 @@ impl<'a> SequenceSerializer<'a> {
336336

337337
#[inline]
338338
fn to_tuple(&self) -> Result<Term<'a>, Error> {
339-
Ok(Tuple::make(self.ser.env, &self.items))
339+
Ok(self.ser.env.make_tuple(&self.items).into())
340340
}
341341
}
342342

‎rustler/src/wrapped_types/list.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,7 @@ where
103103
}
104104
}
105105

106-
impl<'a, T> Encoder for &'a [T]
106+
impl<T> Encoder for &[T]
107107
where
108108
T: Encoder,
109109
{
@@ -131,7 +131,7 @@ impl<'a> ListIterator<'a> {
131131
Some(len as usize)
132132
}
133133

134-
pub fn empty(&self) -> bool {
134+
pub fn is_empty(&self) -> bool {
135135
self.is_empty_list()
136136
}
137137

‎rustler/src/wrapped_types/reference.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ use crate::sys::enif_make_ref;
44

55
use super::wrapper;
66

7-
wrapper!{
7+
wrapper! {
88
struct Reference(TermType::Ref)
99
}
1010

‎rustler/src/wrapped_types/tuple.rs

Lines changed: 13 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ wrapper!(
99
struct Tuple(TermType::Tuple)
1010
);
1111

12-
pub unsafe fn get_tuple<'a>(term: Term<'a>) -> NifResult<&'a [ERL_NIF_TERM]> {
12+
pub unsafe fn get_tuple(term: Term<'_>) -> NifResult<&[ERL_NIF_TERM]> {
1313
let env = term.get_env();
1414
let mut arity: c_int = 0;
1515
let mut array_ptr = MaybeUninit::uninit();
@@ -27,11 +27,11 @@ pub unsafe fn get_tuple<'a>(term: Term<'a>) -> NifResult<&'a [ERL_NIF_TERM]> {
2727
}
2828

2929
impl<'a> Tuple<'a> {
30-
pub fn make(env: Env<'a>, terms: &[Term<'a>]) -> Term<'a> {
31-
make_tuple(env, terms)
30+
pub fn is_empty(&self) -> bool {
31+
self.len() == 0
3232
}
3333

34-
pub fn size(&self) -> usize {
34+
pub fn len(&self) -> usize {
3535
self.get_elements().len()
3636
}
3737

@@ -58,16 +58,21 @@ impl<'a> Tuple<'a> {
5858
}
5959
}
6060

61+
impl<'a> Env<'a> {
62+
pub fn make_tuple(&self, terms: &[Term<'a>]) -> Tuple<'a> {
63+
make_tuple(*self, terms)
64+
}
65+
}
66+
6167
/// Convert a vector of terms to an Erlang tuple. (To convert from a Rust tuple to an Erlang tuple,
6268
/// use `Encoder` instead.)
63-
pub fn make_tuple<'a>(env: Env<'a>, terms: &[Term]) -> Term<'a> {
69+
pub fn make_tuple<'a>(env: Env<'a>, terms: &[Term]) -> Tuple<'a> {
6470
let c_terms: Vec<ERL_NIF_TERM> = terms.iter().map(|term| term.as_c_arg()).collect();
6571
unsafe {
6672
let term =
6773
enif_make_tuple_from_array(env.as_c_arg(), c_terms.as_ptr(), c_terms.len() as u32);
68-
Term::new(env, term)
74+
Term::new(env, term).try_into().unwrap()
6975
}
70-
// unsafe { Term::new(env, tuple::make_tuple(env.as_c_arg(), &c_terms)) }
7176
}
7277

7378
/// 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 {
9499
{
95100
fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
96101
let arr = [ $( Encoder::encode(&self.$index, env) ),* ];
97-
make_tuple(env, &arr)
102+
make_tuple(env, &arr).into()
98103
}
99104
}
100105

‎rustler_codegen/src/encode_decode_templates.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,7 @@ pub(crate) fn encoder(ctx: &Context, inner: TokenStream) -> TokenStream {
153153
impl #impl_generics ::rustler::Encoder for #ident #ty_generics #where_clause {
154154
#[allow(clippy::needless_borrow)]
155155
fn encode<'__rustler__encode_lifetime>(&self, env: ::rustler::Env<'__rustler__encode_lifetime>) -> ::rustler::Term<'__rustler__encode_lifetime> {
156-
#inner
156+
#inner.into()
157157
}
158158
}
159159
}

‎rustler_codegen/src/record.rs

Lines changed: 11 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,7 @@ fn gen_decoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
103103
quote! {
104104
use #atoms_module_name::*;
105105

106-
let terms = match ::rustler::types::tuple::get_tuple(term) {
106+
let terms = match ::rustler::Tuple::try_from(term) {
107107
Err(_) => return Err(::rustler::Error::RaiseTerm(
108108
Box::new(format!("Invalid Record structure for {}", #struct_name_str)))),
109109
Ok(value) => value,
@@ -113,19 +113,24 @@ fn gen_decoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
113113
return Err(::rustler::Error::RaiseAtom("invalid_record"));
114114
}
115115

116-
let tag : ::rustler::types::atom::Atom = terms[0].decode()?;
116+
let tag : ::rustler::types::atom::Atom = terms.get(0).unwrap().decode()?;
117117

118118
if tag != atom_tag() {
119119
return Err(::rustler::Error::RaiseAtom("invalid_record"));
120120
}
121121

122-
fn try_decode_index<'a, T>(terms: &[::rustler::Term<'a>], pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
122+
fn try_decode_index<'a, T>(terms: &::rustler::Tuple<'a>, pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
123123
where
124124
T: rustler::Decoder<'a>,
125125
{
126-
match ::rustler::Decoder::decode(terms[index]) {
126+
use ::rustler::{Decoder, Error};
127+
128+
let term = terms.get(index).ok_or_else(|| Error::BadArg)?;
129+
130+
match term.decode() {
127131
Err(_) => Err(::rustler::Error::RaiseTerm(Box::new(
128-
format!("Could not decode field {} on Record {}", pos_in_struct, #struct_name_str)))),
132+
format!("Could not decode field {} on Record {}", pos_in_struct, #struct_name_str))
133+
)),
129134
Ok(value) => Ok(value)
130135
}
131136
}
@@ -166,7 +171,7 @@ fn gen_encoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
166171

167172
use ::rustler::Encoder;
168173
let arr = #field_list_ast;
169-
::rustler::types::tuple::make_tuple(env, &arr)
174+
env.make_tuple(&arr)
170175
},
171176
)
172177
}

‎rustler_codegen/src/tagged_enum.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -141,10 +141,10 @@ fn gen_decoder(ctx: &Context, variants: &[&Variant], atoms_module_name: &Ident)
141141

142142
if let Ok(unit) = ::rustler::types::atom::Atom::from_term(term) {
143143
#(#unit_decoders)*
144-
} else if let Ok(tuple) = ::rustler::types::tuple::get_tuple(term) {
144+
} else if let Ok(tuple) = ::rustler::Tuple::try_from(term) {
145145
let name = tuple
146146
.get(0)
147-
.and_then(|&first| ::rustler::types::atom::Atom::from_term(first).ok())
147+
.and_then(|first| ::rustler::types::atom::Atom::from_term(first).ok())
148148
.ok_or(::rustler::Error::RaiseAtom("invalid_variant"))?;
149149
#(#named_unnamed_decoders)*
150150
}
@@ -208,7 +208,7 @@ fn gen_unnamed_decoder<'a>(
208208
let i = i + 1;
209209
let ty = &f.ty;
210210
quote! {
211-
<#ty as ::rustler::Decoder>::decode(tuple[#i]).map_err(|_| ::rustler::Error::RaiseTerm(
211+
<#ty as ::rustler::Decoder>::decode(tuple.get(#i).unwrap()).map_err(|_| ::rustler::Error::RaiseTerm(
212212
Box::new(format!("Could not decode field on position {}", #i))
213213
))?
214214
}
@@ -250,7 +250,7 @@ fn gen_named_decoder(
250250
let enum_name_string = enum_name.to_string();
251251

252252
let assignment = quote_spanned! { field.span() =>
253-
let #variable = try_decode_field(tuple[1], #atom_fun()).map_err(|_|{
253+
let #variable = try_decode_field(tuple.get(1).unwrap(), #atom_fun()).map_err(|_|{
254254
::rustler::Error::RaiseTerm(Box::new(format!(
255255
"Could not decode field '{}' on Enum '{}'",
256256
#ident_string, #enum_name_string
@@ -267,7 +267,7 @@ fn gen_named_decoder(
267267

268268
quote! {
269269
if tuple.len() == 2 && name == #atom_fn() {
270-
let len = tuple[1].map_size().map_err(|_| ::rustler::Error::RaiseTerm(Box::new(
270+
let len = tuple.get(1).unwrap().map_size().map_err(|_| ::rustler::Error::RaiseTerm(Box::new(
271271
"The second element of the tuple must be a map"
272272
)))?;
273273
#(#assignments)*
@@ -334,7 +334,7 @@ fn gen_named_encoder(
334334
} => {
335335
let map = ::rustler::Term::map_from_term_arrays(env, &[#(#keys),*], &[#(#values),*])
336336
.expect("Failed to create map");
337-
::rustler::types::tuple::make_tuple(env, &[::rustler::Encoder::encode(&#atom_fn(), env), map])
337+
env.make_tuple(&[::rustler::Encoder::encode(&#atom_fn(), env), map]).into()
338338
}
339339
}
340340
}

‎rustler_codegen/src/tuple.rs

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -84,18 +84,22 @@ fn gen_decoder(ctx: &Context, fields: &[&Field]) -> TokenStream {
8484
super::encode_decode_templates::decoder(
8585
ctx,
8686
quote! {
87-
let terms = ::rustler::types::tuple::get_tuple(term)?;
87+
let terms = ::rustler::Tuple::try_from(term)?;
8888
if terms.len() != #field_num {
8989
return Err(::rustler::Error::BadArg);
9090
}
9191

92-
fn try_decode_index<'a, T>(terms: &[::rustler::Term<'a>], pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
92+
fn try_decode_index<'a, T>(terms: &::rustler::Tuple<'a>, pos_in_struct: &str, index: usize) -> ::rustler::NifResult<T>
9393
where
9494
T: rustler::Decoder<'a>,
9595
{
96-
match ::rustler::Decoder::decode(terms[index]) {
97-
Err(_) => Err(::rustler::Error::RaiseTerm(Box::new(
98-
format!("Could not decode field {} on {}", pos_in_struct, #struct_name_str)))),
96+
use ::rustler::{Decoder, Error};
97+
98+
let term = terms.get(index).ok_or_else(|| Error::BadArg)?;
99+
match term.decode() {
100+
Err(_) => Err(Error::RaiseTerm(Box::new(
101+
format!("Could not decode field {} on {}", pos_in_struct, #struct_name_str))
102+
)),
99103
Ok(value) => Ok(value)
100104
}
101105
}
@@ -131,7 +135,7 @@ fn gen_encoder(ctx: &Context, fields: &[&Field]) -> TokenStream {
131135
quote! {
132136
use ::rustler::Encoder;
133137
let arr = #field_list_ast;
134-
::rustler::types::tuple::make_tuple(env, &arr)
138+
env.make_tuple(&arr)
135139
},
136140
)
137141
}

‎rustler_tests/native/rustler_serde_test/src/lib.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ mod types;
1111

1212
use crate::types::Animal;
1313
use rustler::serde::{atoms, Deserializer, Error, Serializer};
14-
use rustler::{types::tuple, Encoder, Env, NifResult, SerdeTerm, Term};
14+
use rustler::{Encoder, Env, NifResult, SerdeTerm, Term};
1515

1616
init!("Elixir.SerdeRustlerTests");
1717

@@ -56,10 +56,10 @@ where
5656

5757
fn ok_tuple<'a>(env: Env<'a>, term: Term<'a>) -> Term<'a> {
5858
let ok_atom_term = atoms::ok().encode(env);
59-
tuple::make_tuple(env, &[ok_atom_term, term])
59+
env.make_tuple(&[ok_atom_term, term]).into()
6060
}
6161

6262
fn error_tuple<'a>(env: Env<'a>, reason_term: Term<'a>) -> Term<'a> {
6363
let err_atom_term = atoms::error().encode(env);
64-
tuple::make_tuple(env, &[err_atom_term, reason_term])
64+
env.make_tuple(&[err_atom_term, reason_term]).into()
6565
}

‎rustler_tests/native/rustler_test/src/test_env.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
use rustler::env::{OwnedEnv, SavedTerm, SendError};
22
use rustler::types::atom;
3-
use rustler::types::list::ListIterator;
43
use rustler::types::LocalPid;
5-
use rustler::{Atom, Encoder, Env, NifResult, Reference, Term};
4+
use rustler::{Atom, Encoder, Env, ListIterator, NifResult, Reference, Term};
65
use std::thread;
76

87
// Send a message to several PIDs.

‎rustler_tests/native/rustler_test/src/test_map.rs

Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,4 @@
1-
use rustler::types::map::MapIterator;
2-
use rustler::types::tuple::make_tuple;
3-
use rustler::{Encoder, Env, Error, ListIterator, NifResult, Term};
1+
use rustler::{Encoder, Env, Error, ListIterator, MapIterator, NifResult, Term, Tuple};
42

53
#[rustler::nif]
64
pub fn sum_map_values(iter: MapIterator) -> NifResult<i64> {
@@ -11,31 +9,31 @@ pub fn sum_map_values(iter: MapIterator) -> NifResult<i64> {
119
}
1210

1311
#[rustler::nif]
14-
pub fn map_entries<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Term<'a>>> {
12+
pub fn map_entries<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Tuple<'a>>> {
1513
let mut vec = vec![];
1614
for (key, value) in iter {
1715
let key_string = key.decode::<String>()?;
1816
vec.push((key_string, value));
1917
}
2018

21-
let erlang_pairs: Vec<Term> = vec
19+
let erlang_pairs: Vec<_> = vec
2220
.into_iter()
23-
.map(|(key, value)| make_tuple(env, &[key.encode(env), value]))
21+
.map(|(key, value)| env.make_tuple(&[key.encode(env), value]))
2422
.collect();
2523
Ok(erlang_pairs)
2624
}
2725

2826
#[rustler::nif]
29-
pub fn map_entries_reversed<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Term<'a>>> {
27+
pub fn map_entries_reversed<'a>(env: Env<'a>, iter: MapIterator<'a>) -> NifResult<Vec<Tuple<'a>>> {
3028
let mut vec = vec![];
3129
for (key, value) in iter.rev() {
3230
let key_string = key.decode::<String>()?;
3331
vec.push((key_string, value));
3432
}
3533

36-
let erlang_pairs: Vec<Term> = vec
34+
let erlang_pairs: Vec<_> = vec
3735
.into_iter()
38-
.map(|(key, value)| make_tuple(env, &[key.encode(env), value]))
36+
.map(|(key, value)| env.make_tuple(&[key.encode(env), value]))
3937
.collect();
4038
Ok(erlang_pairs)
4139
}

0 commit comments

Comments
 (0)