fn _call_with_extra_args()

in rhai/src/types/fn_ptr.rs [414:518]

• 102 lines of code
• 18 McCabe index (conditional complexity)

    fn _call_with_extra_args<const N: usize, const E: usize>(
        &self,
        fn_name: &str,
        ctx: &NativeCallContext,
        mut this_ptr: Option<&mut Dynamic>,
        args: [Dynamic; N],
        extras: [Dynamic; E],
        move_this_ptr_to_args: Option<usize>,
    ) -> RhaiResult {
        #[cfg(not(feature = "no_function"))]
        if let Some(arity) = self.fn_def().map(|f| f.params.len()) {
            if arity == N + self.curry().len() {
                return self.call_raw(ctx, this_ptr, args);
            }
            if let Some(move_to_args) = move_this_ptr_to_args {
                if this_ptr.is_some() {
                    if arity == N + 1 + self.curry().len() {
                        let mut args2 = FnArgsVec::with_capacity(args.len() + 1);
                        if move_to_args == 0 {
                            args2.push(this_ptr.as_mut().unwrap().clone());
                            args2.extend(args);
                        } else {
                            args2.extend(args);
                            args2.insert(move_to_args, this_ptr.as_mut().unwrap().clone());
                        }
                        return self.call_raw(ctx, None, args2);
                    }
                    if arity == N + E + 1 + self.curry().len() {
                        let mut args2 = FnArgsVec::with_capacity(args.len() + extras.len() + 1);
                        if move_to_args == 0 {
                            args2.push(this_ptr.as_mut().unwrap().clone());
                            args2.extend(args);
                            args2.extend(extras);
                        } else {
                            args2.extend(args);
                            args2.insert(move_to_args, this_ptr.as_mut().unwrap().clone());
                            args2.extend(extras);
                        }
                        return self.call_raw(ctx, None, args2);
                    }
                }
            }
            if arity == N + E + self.curry().len() {
                let mut args2 = FnArgsVec::with_capacity(args.len() + extras.len());
                args2.extend(args);
                args2.extend(extras);
                return self.call_raw(ctx, this_ptr, args2);
            }
        }

        self.call_raw(ctx, this_ptr.as_deref_mut(), args.clone())
            .or_else(|err| match *err {
                ERR::ErrorFunctionNotFound(sig, ..)
                    if move_this_ptr_to_args.is_some()
                        && this_ptr.is_some()
                        && sig.starts_with(self.fn_name()) =>
                {
                    let mut args2 = FnArgsVec::with_capacity(args.len() + 1);
                    let move_to_args = move_this_ptr_to_args.unwrap();
                    if move_to_args == 0 {
                        args2.push(this_ptr.as_mut().unwrap().clone());
                        args2.extend(args.clone());
                    } else {
                        args2.extend(args.clone());
                        args2.insert(move_to_args, this_ptr.as_mut().unwrap().clone());
                    }
                    self.call_raw(ctx, None, args2)
                }
                _ => Err(err),
            })
            .or_else(|err| match *err {
                ERR::ErrorFunctionNotFound(sig, ..) if sig.starts_with(self.fn_name()) => {
                    if let Some(move_to_args) = move_this_ptr_to_args {
                        if let Some(ref mut this_ptr) = this_ptr {
                            let mut args2 = FnArgsVec::with_capacity(args.len() + extras.len() + 1);
                            if move_to_args == 0 {
                                args2.push(this_ptr.clone());
                                args2.extend(args);
                                args2.extend(extras);
                            } else {
                                args2.extend(args);
                                args2.extend(extras);
                                args2.insert(move_to_args, this_ptr.clone());
                            }
                            return self.call_raw(ctx, None, args2);
                        }
                    }

                    let mut args2 = FnArgsVec::with_capacity(args.len() + extras.len());
                    args2.extend(args);
                    args2.extend(extras);

                    self.call_raw(ctx, this_ptr, args2)
                }
                _ => Err(err),
            })
            .map_err(|err| {
                Box::new(ERR::ErrorInFunctionCall(
                    fn_name.to_string(),
                    ctx.source().unwrap_or("").to_string(),
                    err,
                    Position::NONE,
                ))
            })
    }