fn new_fuzzed()

in lain/src/new_fuzzed.rs [776:823]
39 lines of code
5 McCabe index (conditional complexity)

                fn new_fuzzed<R: Rng>(mutator: &mut Mutator<R>, constraints: Option<&Constraints<Self::RangeType>>) -> [T; $size] {
                    let mut per_item_max_size: Option<usize> = constraints.and_then(|c| c.max_size.as_ref().and_then(|size| Some(*size / $size)));

                    let mut output: MaybeUninit<[T; $size]> = MaybeUninit::uninit();
                    let arr_ptr = output.as_mut_ptr() as *mut T;

                    let constraints = per_item_max_size.as_ref().map(|size| {
                        let mut constraints = Constraints::new();
                        constraints.max_size(*size);
                        constraints.set_base_size_accounted_for();

                        constraints
                    });

                    let mut idx = 0;
                    let mut element: T = T::new_fuzzed(mutator, constraints.as_ref());

                    while idx < $size {
                        unsafe {
                            arr_ptr.add(idx).write(element.clone());
                        }

                        idx += 1;
                        if $size - idx > 0 {
                            if mutator.gen_chance(crate::mutator::CHANCE_TO_REPEAT_ARRAY_VALUE) {
                                let repeat_end_idx = mutator.gen_range(idx, $size);
                                while idx < repeat_end_idx {
                                    unsafe {
                                        arr_ptr.add(idx).write(element.clone());
                                    }
                                    idx += 1;
                                }
                            } else {
                                let constraints = per_item_max_size.as_ref().map(|size| {
                                    let mut constraints = Constraints::new();
                                    constraints.max_size(*size);
                                    constraints.set_base_size_accounted_for();

                                    constraints
                                });

                                element = T::new_fuzzed(mutator, constraints.as_ref());
                            }
                        }
                    }

                    unsafe { output.assume_init() }
                }