Merge pull request #671 from rusterlium/clippy

Fix clippy lints

Author: filmor

rustler/build.rs

@@ -49,7 +49,7 @@ fn write_variadic_fn_type(out: &mut String, args: &str, ret: &str) {
 }
 
 pub struct CallbacksApiBuilder<'a>(&'a mut String);
-impl<'a> ApiBuilder for CallbacksApiBuilder<'a> {
+impl ApiBuilder for CallbacksApiBuilder<'_> {
     fn init(&mut self) {
         writeln!(self.0, "#[allow(dead_code)]").unwrap();
         writeln!(self.0, "#[derive(Default, Copy, Clone)]").unwrap();
@@ -78,7 +78,7 @@ impl<'a> ApiBuilder for CallbacksApiBuilder<'a> {
 }
 
 pub struct ForwardersApiBuilder<'a>(&'a mut String);
-impl<'a> ApiBuilder for ForwardersApiBuilder<'a> {
+impl ApiBuilder for ForwardersApiBuilder<'_> {
     fn func(&mut self, ret: &str, name: &str, args: &str) {
         // This regex takes a list of args with types and return only the name of the args.
         //
@@ -135,7 +135,7 @@ impl<'a> ApiBuilder for ForwardersApiBuilder<'a> {
 
 pub struct WriterBuilder<'a>(&'a mut String);
 
-impl<'a> ApiBuilder for WriterBuilder<'a> {
+impl ApiBuilder for WriterBuilder<'_> {
     fn init(&mut self) {
         write!(
             self.0,

rustler/src/dynamic.rs

@@ -85,7 +85,7 @@ macro_rules! impl_check {
 }
 
 /// ## Type checks
-impl<'a> Term<'a> {
+impl Term<'_> {
     /// Returns an enum representing which type the term is.
     /// Note that using the individual `is_*` functions is more
     /// efficient for checking a single type.

rustler/src/env.rs

@@ -35,7 +35,7 @@ pub struct Env<'a> {
 /// Two environments are equal if they're the same `NIF_ENV` value.
 ///
 /// A `Env<'a>` is equal to a `Env<'b>` if and only if `'a` and `'b` are the same lifetime.
-impl<'a, 'b> PartialEq<Env<'b>> for Env<'a> {
+impl<'b> PartialEq<Env<'b>> for Env<'_> {
     fn eq(&self, other: &Env<'b>) -> bool {
         self.env == other.env
     }

rustler/src/resource/registration.rs

@@ -24,7 +24,7 @@ unsafe impl Sync for Registration {}
 
 inventory::collect!(Registration);
 
-impl<'a> Env<'a> {
+impl Env<'_> {
     /// Register a resource type, see `Registration::register`.
     pub fn register<T: Resource>(&self) -> Result<(), ResourceInitError> {
         Registration::new::<T>().register(*self)

rustler/src/resource/traits.rs

@@ -12,6 +12,7 @@ type NifResourcePtr = *const ErlNifResourceType;
 static mut RESOURCE_TYPES: OnceLock<HashMap<TypeId, usize>> = OnceLock::new();
 
 /// Register an Erlang resource type handle for a particular type given by its `TypeId`
+#[allow(static_mut_refs)]
 pub(crate) unsafe fn register_resource_type(type_id: TypeId, resource_type: NifResourcePtr) {
     RESOURCE_TYPES.get_or_init(Default::default);
     RESOURCE_TYPES
@@ -64,6 +65,7 @@ pub trait Resource: Sized + Send + Sync + 'static {
 #[doc(hidden)]
 pub(crate) trait ResourceExt: 'static {
     /// Get the NIF resource type handle for this type if it had been registered before
+    #[allow(static_mut_refs)]
     fn get_resource_type() -> Option<NifResourcePtr> {
         let map = unsafe { RESOURCE_TYPES.get()? };
         map.get(&TypeId::of::<Self>())

rustler/src/return.rs

@@ -7,7 +7,7 @@ pub enum Return<'a> {
     Error(Error),
 }
 
-unsafe impl<'b> NifReturnable for Return<'b> {
+unsafe impl NifReturnable for Return<'_> {
     unsafe fn into_returned(self, env: Env) -> NifReturned {
         match self {
             Return::Term(inner) => NifReturned::Term(inner.as_c_arg()),

rustler/src/sys/functions.rs

@@ -10,6 +10,7 @@ pub unsafe fn internal_set_symbols(callbacks: DynNifCallbacks) {
     DYN_NIF_CALLBACKS = callbacks;
 }
 
+#[allow(static_mut_refs)]
 pub unsafe fn internal_write_symbols() {
     let filler = nif_filler::new();
     DYN_NIF_CALLBACKS.write_symbols(filler);

rustler/src/term.rs

@@ -17,7 +17,7 @@ pub struct Term<'a> {
     env: Env<'a>,
 }
 
-impl<'a> Debug for Term<'a> {
+impl Debug for Term<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         crate::wrapper::term::fmt(self.as_c_arg(), f)
     }
@@ -121,12 +121,12 @@ impl<'a> Term<'a> {
     }
 }
 
-impl<'a> PartialEq for Term<'a> {
+impl PartialEq for Term<'_> {
     fn eq(&self, other: &Term) -> bool {
         unsafe { enif_is_identical(self.as_c_arg(), other.as_c_arg()) == 1 }
     }
 }
-impl<'a> Eq for Term<'a> {}
+impl Eq for Term<'_> {}
 
 fn cmp(lhs: &Term, rhs: &Term) -> Ordering {
     let ord = unsafe { enif_compare(lhs.as_c_arg(), rhs.as_c_arg()) };
@@ -137,7 +137,7 @@ fn cmp(lhs: &Term, rhs: &Term) -> Ordering {
     }
 }
 
-impl<'a> Ord for Term<'a> {
+impl Ord for Term<'_> {
     fn cmp(&self, other: &Term) -> Ordering {
         cmp(self, other)
     }
@@ -148,7 +148,7 @@ impl<'a> PartialOrd for Term<'a> {
     }
 }
 
-impl<'a> Hash for Term<'a> {
+impl Hash for Term<'_> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // As far as I can see, there is really no way
         // to get a seed from the hasher. This is definitely
@@ -157,5 +157,5 @@ impl<'a> Hash for Term<'a> {
     }
 }
 
-unsafe impl<'a> Sync for Term<'a> {}
-unsafe impl<'a> Send for Term<'a> {}
+unsafe impl Sync for Term<'_> {}
+unsafe impl Send for Term<'_> {}

rustler/src/types/atom.rs

@@ -106,7 +106,7 @@ impl<'a> PartialEq<Term<'a>> for Atom {
 }
 
 /// ## Atom terms
-impl<'a> Term<'a> {
+impl Term<'_> {
     /// When the term is an atom, this method will return the string
     /// representation of it.
     ///

rustler/src/types/big_int.rs

@@ -1,18 +1,3 @@
-use crate::{Decoder, Encoder, Env, Error, NifResult, Term};
-
-use num_bigint::{BigInt, Sign};
-
-// From https://www.erlang.org/doc/apps/erts/erl_ext_dist.html
-const EXTERNAL_TERM_FORMAT_VERSION: u8 = 131;
-const SMALL_INTEGER: u8 = 97;
-const INTEGER: u8 = 98;
-const SMALL_BIG_EXT: u8 = 110;
-const LARGE_BIG_EXT: u8 = 111;
-
-crate::atoms! {
-    big_int_encoder_invalid_bytes
-}
-
 /// Implementation of [Decoder](rustler::Decoder) and [Encoder](rustler::Encoder) traits for
 /// num-bigint.
 ///
@@ -48,6 +33,20 @@ crate::atoms! {
 /// }
 /// ```
 ///
+use crate::{Decoder, Encoder, Env, Error, NifResult, Term};
+
+use num_bigint::{BigInt, Sign};
+
+// From https://www.erlang.org/doc/apps/erts/erl_ext_dist.html
+const EXTERNAL_TERM_FORMAT_VERSION: u8 = 131;
+const SMALL_INTEGER: u8 = 97;
+const INTEGER: u8 = 98;
+const SMALL_BIG_EXT: u8 = 110;
+const LARGE_BIG_EXT: u8 = 111;
+
+crate::atoms! {
+    big_int_encoder_invalid_bytes
+}
 
 fn decode_big_integer(input: &[u8]) -> NifResult<BigInt> {
     if Some(&EXTERNAL_TERM_FORMAT_VERSION) != input.first() {