fix more clippy warnings

Author: Mrmaxmeier

lain/src/dangerous_numbers.rs

@@ -2,61 +2,61 @@ use crate::rand::Rng;
 use crate::traits::*;
 
 static DANGEROUS_NUMBERS_U8: &[u8] = &[
-    std::u8::MIN,             // 0x00
-    std::u8::MAX,             // 0xff
-    std::i8::MAX as u8,       // 0x7f
-    (std::i8::MAX as u8) + 1, // 0x80
+    u8::MIN,             // 0x00
+    u8::MAX,             // 0xff
+    i8::MAX as u8,       // 0x7f
+    (i8::MAX as u8) + 1, // 0x80
 ];
 
 static DANGEROUS_NUMBERS_U16: &[u16] = &[
     // big-endian variants
-    std::u16::MIN,              // 0x0000
-    std::u16::MAX,              // 0xffff
-    std::i16::MAX as u16,       // 0x7fff
-    (std::i16::MAX as u16) + 1, // 0x8000
+    u16::MIN,              // 0x0000
+    u16::MAX,              // 0xffff
+    i16::MAX as u16,       // 0x7fff
+    (i16::MAX as u16) + 1, // 0x8000
     // little-endian variants
     0xff7f,
     0x0080,
 ];
 
 static DANGEROUS_NUMBERS_U32: &[u32] = &[
     // big-endian variants
-    std::u32::MIN,
-    std::u32::MAX,
-    std::i32::MAX as u32,
-    (std::i32::MAX as u32) + 1,
+    u32::MIN,
+    u32::MAX,
+    i32::MAX as u32,
+    (i32::MAX as u32) + 1,
     // little-endian variants
     0xffff_ff7f,
     0x0000_0080,
 ];
 
 static DANGEROUS_NUMBERS_U64: &[u64] = &[
     // big-endian variants
-    std::u64::MIN,
-    std::u64::MAX,
-    std::i64::MAX as u64,
-    (std::i64::MAX as u64) + 1,
+    u64::MIN,
+    u64::MAX,
+    i64::MAX as u64,
+    (i64::MAX as u64) + 1,
     // little-endian variants
     0xffff_ffff_ffff_ff7f,
     0x0000_0000_0000_0080,
 ];
 
 static DANGEROUS_NUMBERS_F32: &[f32] = &[
-    std::f32::INFINITY,
-    std::f32::MAX,
-    std::f32::MIN,
-    std::f32::MIN_POSITIVE,
-    std::f32::NAN,
-    std::f32::NEG_INFINITY,
+    f32::INFINITY,
+    f32::MAX,
+    f32::MIN,
+    f32::MIN_POSITIVE,
+    f32::NAN,
+    f32::NEG_INFINITY,
 ];
 
 static DANGEROUS_NUMBERS_F64: &[f64] = &[
-    std::f64::INFINITY,
-    std::f64::MAX,
-    std::f64::MIN,
-    std::f64::MIN_POSITIVE,
-    std::f64::NAN,
-    std::f64::NEG_INFINITY,
+    f64::INFINITY,
+    f64::MAX,
+    f64::MIN,
+    f64::MIN_POSITIVE,
+    f64::NAN,
+    f64::NEG_INFINITY,
 ];
 
 macro_rules! dangerous_number {

lain/src/driver.rs

@@ -243,7 +243,8 @@ pub fn start_fuzzer<F: 'static, C: 'static, T: 'static + Send + Sync>(
 
                     mutator.random_flags();
 
-                    if (callback)(&mut mutator, &mut context, thread_driver.global_context()).is_err()
+                    if (callback)(&mut mutator, &mut context, thread_driver.global_context())
+                        .is_err()
                     {
                         thread_driver
                             .num_failed_iterations

lain/src/mutator.rs

@@ -43,7 +43,6 @@ pub struct CorpusFuzzingState {
     fields_fuzzed: usize,
 }
 
-
 impl CorpusFuzzingState {
     pub fn reset(&mut self) {
         self.fields_fuzzed = 0;

lain/src/new_fuzzed.rs

@@ -704,13 +704,13 @@ macro_rules! impl_new_fuzzed {
 
                             min = if let Some(ref min) = constraints.min {
                                 if mutator.gen_chance(crate::mutator::CHANCE_TO_IGNORE_MIN_MAX) {
-                                    $name::min_value()
+                                    $name::MIN
                                 } else {
                                     ignore_min = false;
                                     *min
                                 }
                             } else {
-                                $name::min_value()
+                                $name::MIN
                             };
 
                             max = if let Some(ref max) = constraints.max {

lain/src/types.rs

@@ -179,12 +179,10 @@ impl<T: Bounded + Debug> Constraints<T> {
 }
 
 /// Which direction to weigh ranges towards (min bound, upper bound, or none).
-#[derive(Debug, PartialEq, Clone, Copy)]
-#[derive(Default)]
+#[derive(Debug, PartialEq, Clone, Copy, Default)]
 pub enum Weighted {
     #[default]
     None,
     Min,
     Max,
 }
-

lain_derive/src/lib.rs

@@ -253,12 +253,10 @@ pub fn fuzzer_object(input: proc_macro::TokenStream) -> proc_macro::TokenStream
 
     let input = parse_macro_input!(input as DeriveInput);
     base_token_stream.extend::<TokenStream>(
-        mutations::expand_new_fuzzed(&input)
-            .unwrap_or_else(to_compile_errors),
+        mutations::expand_new_fuzzed(&input).unwrap_or_else(to_compile_errors),
     );
     base_token_stream.extend::<TokenStream>(
-        mutations::expand_mutatable(&input)
-            .unwrap_or_else(to_compile_errors),
+        mutations::expand_mutatable(&input).unwrap_or_else(to_compile_errors),
     );
     base_token_stream.extend::<TokenStream>(variable_size_object_helper(&input));
 

lain_derive/src/mutations.rs

@@ -477,7 +477,9 @@ fn new_fuzzed_struct_visitor(fields: &[Field], cont_ident: &syn::Ident) -> Vec<T
 
 fn struct_field_constraints(field: &Field, for_mutation: bool) -> TokenStream {
     let attrs = &field.attrs;
-    if !for_mutation && (attrs.ignore() || (attrs.initializer().is_some() && attrs.ignore_chance().is_none())) {
+    if !for_mutation
+        && (attrs.ignore() || (attrs.initializer().is_some() && attrs.ignore_chance().is_none()))
+    {
         return TokenStream::new();
     }