Clippy warning in generated code: too many arguments

[RickySyndica]

Perhaps it'd be possible to suppress this in generated code? I have a function with 7 arguments, which becomes 8 when the mock is generated

Thanks!

[asomers]

I suppress that warning at the module level. See

mockall/mockall/tests/automock_many_args.rs

Line 3 in 5938237

#![allow(clippy::too_many_arguments)] // Good job, Clippy!

. I assume you also suppress it somewhere? I suppose that if you only suppress it on the function that needs it, you'd see this warning for the mock function. Are you using mock! or automock? If the latter, than mockall should copy the suppression attribute.

[RickySyndica]

Hi there, thanks for the quick response!

I am using the #[automock] annotation. I've created a minimal reproducer (see below). cargo expand (link) does not show the clippy::too_many_arguments annotation anywhere in the generated code

#![allow(dead_code, unused_variables)]
struct Foo;

#[mockall::automock]
impl Foo {
    fn bar(a: (), b: (), c: (), d: (), e: (), f: (), g: ()) {}
}

Expanded code

#![feature(prelude_import)]
#![allow(dead_code, unused_variables)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
struct Foo;
impl Foo {
    fn bar(a: (), b: (), c: (), d: (), e: (), f: (), g: ()) {}
}
#[allow(non_snake_case)]
#[allow(missing_docs)]
pub mod __mock_MockFoo {
    use super::*;
    #[allow(missing_docs)]
    pub mod __bar {
        use super::*;
        use ::mockall::CaseTreeExt;
        use ::std::sync::MutexGuard;
        use ::std::{
            boxed::Box, mem, ops::{DerefMut, Range},
            sync::Mutex, vec::Vec,
        };
        #[allow(clippy::unused_unit)]
        enum Rfunc {
            Default,
            Expired,
            Mut(Box<dyn FnMut((), (), (), (), (), (), ()) -> () + Send>),
            MutSt(::mockall::Fragile<Box<dyn FnMut((), (), (), (), (), (), ()) -> ()>>),
            Once(Box<dyn FnOnce((), (), (), (), (), (), ()) -> () + Send>),
            OnceSt(
                ::mockall::Fragile<Box<dyn FnOnce((), (), (), (), (), (), ()) -> ()>>,
            ),
            _Phantom(Box<dyn Fn() + Send>),
        }
        impl Rfunc {
            fn call_mut(
                &mut self,
                a: (),
                b: (),
                c: (),
                d: (),
                e: (),
                f: (),
                g: (),
            ) -> std::result::Result<(), &'static str> {
                match self {
                    Rfunc::Default => {
                        use ::mockall::ReturnDefault;
                        ::mockall::DefaultReturner::<()>::return_default()
                    }
                    Rfunc::Expired => Err("called twice, but it returns by move"),
                    Rfunc::Mut(__mockall_f) => {
                        ::std::result::Result::Ok(__mockall_f(a, b, c, d, e, f, g))
                    }
                    Rfunc::MutSt(__mockall_f) => {
                        ::std::result::Result::Ok(
                            (__mockall_f.get_mut())(a, b, c, d, e, f, g),
                        )
                    }
                    Rfunc::Once(_) => {
                        if let Rfunc::Once(mut __mockall_f)
                            = mem::replace(self, Rfunc::Expired) {
                            ::std::result::Result::Ok(__mockall_f(a, b, c, d, e, f, g))
                        } else {
                            ::core::panicking::panic(
                                "internal error: entered unreachable code",
                            )
                        }
                    }
                    Rfunc::OnceSt(_) => {
                        if let Rfunc::OnceSt(mut __mockall_f)
                            = mem::replace(self, Rfunc::Expired) {
                            ::std::result::Result::Ok(
                                (__mockall_f.into_inner())(a, b, c, d, e, f, g),
                            )
                        } else {
                            ::core::panicking::panic(
                                "internal error: entered unreachable code",
                            )
                        }
                    }
                    Rfunc::_Phantom(_) => {
                        ::core::panicking::panic(
                            "internal error: entered unreachable code",
                        )
                    }
                }
            }
        }
        impl std::default::Default for Rfunc {
            fn default() -> Self {
                Rfunc::Default
            }
        }
        enum Matcher {
            Always,
            Func(Box<dyn Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + Send>),
            FuncSt(
                ::mockall::Fragile<
                    Box<dyn Fn(&(), &(), &(), &(), &(), &(), &()) -> bool>,
                >,
            ),
            Pred(
                Box<
                    (
                        Box<dyn ::mockall::Predicate<()> + Send>,
                        Box<dyn ::mockall::Predicate<()> + Send>,
                        Box<dyn ::mockall::Predicate<()> + Send>,
                        Box<dyn ::mockall::Predicate<()> + Send>,
                        Box<dyn ::mockall::Predicate<()> + Send>,
                        Box<dyn ::mockall::Predicate<()> + Send>,
                        Box<dyn ::mockall::Predicate<()> + Send>,
                    ),
                >,
            ),
            _Phantom(Box<dyn Fn() + Send>),
        }
        impl Matcher {
            #[allow(clippy::ptr_arg)]
            fn matches(
                &self,
                a: &(),
                b: &(),
                c: &(),
                d: &(),
                e: &(),
                f: &(),
                g: &(),
            ) -> bool {
                match self {
                    Matcher::Always => true,
                    Matcher::Func(__mockall_f) => __mockall_f(a, b, c, d, e, f, g),
                    Matcher::FuncSt(__mockall_f) => {
                        (__mockall_f.get())(a, b, c, d, e, f, g)
                    }
                    Matcher::Pred(__mockall_pred) => {
                        [
                            __mockall_pred.0.eval(a),
                            __mockall_pred.1.eval(b),
                            __mockall_pred.2.eval(c),
                            __mockall_pred.3.eval(d),
                            __mockall_pred.4.eval(e),
                            __mockall_pred.5.eval(f),
                            __mockall_pred.6.eval(g),
                        ]
                            .iter()
                            .all(|__mockall_x| *__mockall_x)
                    }
                    _ => {
                        ::core::panicking::panic(
                            "internal error: entered unreachable code",
                        )
                    }
                }
            }
        }
        impl Default for Matcher {
            #[allow(unused_variables)]
            fn default() -> Self {
                Matcher::Always
            }
        }
        impl ::std::fmt::Display for Matcher {
            fn fmt(
                &self,
                __mockall_fmt: &mut ::std::fmt::Formatter<'_>,
            ) -> ::std::fmt::Result {
                match self {
                    Matcher::Always => {
                        __mockall_fmt.write_fmt(format_args!("<anything>"))
                    }
                    Matcher::Func(_) => {
                        __mockall_fmt.write_fmt(format_args!("<function>"))
                    }
                    Matcher::FuncSt(_) => {
                        __mockall_fmt
                            .write_fmt(format_args!("<single threaded function>"))
                    }
                    Matcher::Pred(__mockall_p) => {
                        __mockall_fmt
                            .write_fmt(
                                format_args!(
                                    "{0}, {1}, {2}, {3}, {4}, {5}, {6}", __mockall_p.0,
                                    __mockall_p.1, __mockall_p.2, __mockall_p.3, __mockall_p.4,
                                    __mockall_p.5, __mockall_p.6
                                ),
                            )
                    }
                    _ => {
                        ::core::panicking::panic(
                            "internal error: entered unreachable code",
                        )
                    }
                }
            }
        }
        /// Holds the stuff that is independent of the output type
        struct Common {
            matcher: Mutex<Matcher>,
            seq_handle: Option<::mockall::SeqHandle>,
            times: ::mockall::Times,
        }
        impl std::default::Default for Common {
            fn default() -> Self {
                Common {
                    matcher: Mutex::new(Matcher::default()),
                    seq_handle: None,
                    times: ::mockall::Times::default(),
                }
            }
        }
        impl Common {
            fn call(&self, desc: &str) {
                self.times
                    .call()
                    .unwrap_or_else(|m| {
                        let desc = {
                            let res = ::alloc::fmt::format(
                                format_args!("{0}", self.matcher.lock().unwrap()),
                            );
                            res
                        };
                        {
                            ::std::rt::panic_fmt(
                                format_args!(
                                    "{0}: Expectation({1}) {2}", "MockFoo::bar", desc, m
                                ),
                            )
                        };
                    });
                self.verify_sequence(desc);
                if ::mockall::ExpectedCalls::TooFew != self.times.is_satisfied() {
                    self.satisfy_sequence()
                }
            }
            fn in_sequence(
                &mut self,
                __mockall_seq: &mut ::mockall::Sequence,
            ) -> &mut Self {
                if !self.times.is_exact() {
                    {
                        ::std::rt::begin_panic(
                            "Only Expectations with an exact call count have sequences",
                        )
                    }
                }
                self.seq_handle = Some(__mockall_seq.next_handle());
                self
            }
            fn is_done(&self) -> bool {
                self.times.is_done()
            }
            #[allow(clippy::ptr_arg)]
            fn matches(
                &self,
                a: &(),
                b: &(),
                c: &(),
                d: &(),
                e: &(),
                f: &(),
                g: &(),
            ) -> bool {
                self.matcher.lock().unwrap().matches(a, b, c, d, e, f, g)
            }
            /// Forbid this expectation from ever being called.
            fn never(&mut self) {
                self.times.never();
            }
            fn satisfy_sequence(&self) {
                if let Some(__mockall_handle) = &self.seq_handle {
                    __mockall_handle.satisfy()
                }
            }
            /// Expect this expectation to be called any number of times
            /// contained with the given range.
            fn times<MockallR>(&mut self, __mockall_r: MockallR)
            where
                MockallR: Into<::mockall::TimesRange>,
            {
                self.times.times(__mockall_r)
            }
            fn with<
                MockallMatcher0: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher1: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher2: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher3: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher4: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher5: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher6: ::mockall::Predicate<()> + Send + 'static,
            >(
                &mut self,
                a: MockallMatcher0,
                b: MockallMatcher1,
                c: MockallMatcher2,
                d: MockallMatcher3,
                e: MockallMatcher4,
                f: MockallMatcher5,
                g: MockallMatcher6,
            ) {
                let mut __mockall_guard = self.matcher.lock().unwrap();
                *__mockall_guard
                    .deref_mut() = Matcher::Pred(
                    Box::new((
                        Box::new(a),
                        Box::new(b),
                        Box::new(c),
                        Box::new(d),
                        Box::new(e),
                        Box::new(f),
                        Box::new(g),
                    )),
                );
            }
            fn withf<MockallF>(&mut self, __mockall_f: MockallF)
            where
                MockallF: Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + Send + 'static,
            {
                let mut __mockall_guard = self.matcher.lock().unwrap();
                *__mockall_guard.deref_mut() = Matcher::Func(Box::new(__mockall_f));
            }
            fn withf_st<MockallF>(&mut self, __mockall_f: MockallF)
            where
                MockallF: Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + 'static,
            {
                let mut __mockall_guard = self.matcher.lock().unwrap();
                *__mockall_guard
                    .deref_mut() = Matcher::FuncSt(
                    ::mockall::Fragile::new(Box::new(__mockall_f)),
                );
            }
            fn verify_sequence(&self, desc: &str) {
                if let Some(__mockall_handle) = &self.seq_handle {
                    __mockall_handle.verify(desc)
                }
            }
        }
        impl Drop for Common {
            fn drop(&mut self) {
                if !::std::thread::panicking() {
                    let desc = {
                        let res = ::alloc::fmt::format(
                            format_args!("{0}", self.matcher.lock().unwrap()),
                        );
                        res
                    };
                    match self.times.is_satisfied() {
                        ::mockall::ExpectedCalls::TooFew => {
                            {
                                ::std::rt::panic_fmt(
                                    format_args!(
                                        "{0}: Expectation({1}) called {2} time(s) which is fewer than expected {3}",
                                        "MockFoo::bar", desc, self.times.count(), self.times
                                        .minimum()
                                    ),
                                )
                            };
                        }
                        ::mockall::ExpectedCalls::TooMany => {
                            {
                                ::std::rt::panic_fmt(
                                    format_args!(
                                        "{0}: Expectation({1}) called {2} time(s) which is more than expected {3}",
                                        "MockFoo::bar", desc, self.times.count(), self.times
                                        .maximum()
                                    ),
                                )
                            };
                        }
                        _ => {}
                    }
                }
            }
        }
        /// Expectation type for methods that return a `'static` type.
        /// This is the type returned by the `expect_*` methods.
        pub(in super::super) struct Expectation {
            common: Common,
            rfunc: Mutex<Rfunc>,
        }
        #[allow(clippy::unused_unit)]
        impl Expectation {
            /// Call this [`Expectation`] as if it were the real method.
            #[doc(hidden)]
            pub(in super::super) fn call(
                &self,
                a: (),
                b: (),
                c: (),
                d: (),
                e: (),
                f: (),
                g: (),
            ) -> () {
                self.common
                    .call(
                        &{
                            let res = ::alloc::fmt::format(
                                format_args!(
                                    "MockFoo::bar({0:?}, {1:?}, {2:?}, {3:?}, {4:?}, {5:?}, {6:?})",
                                    ::mockall::MaybeDebugger(& a), ::mockall::MaybeDebugger(&
                                    b), ::mockall::MaybeDebugger(& c),
                                    ::mockall::MaybeDebugger(& d), ::mockall::MaybeDebugger(&
                                    e), ::mockall::MaybeDebugger(& f),
                                    ::mockall::MaybeDebugger(& g)
                                ),
                            );
                            res
                        },
                    );
                self.rfunc
                    .lock()
                    .unwrap()
                    .call_mut(a, b, c, d, e, f, g)
                    .unwrap_or_else(|message| {
                        let desc = {
                            let res = ::alloc::fmt::format(
                                format_args!("{0}", self.common.matcher.lock().unwrap()),
                            );
                            res
                        };
                        {
                            ::std::rt::panic_fmt(
                                format_args!(
                                    "{0}: Expectation({1}) {2}", "MockFoo::bar", desc, message
                                ),
                            )
                        };
                    })
            }
            /// Return a constant value from the `Expectation`
            ///
            /// The output type must be `Clone`.  The compiler can't always
            /// infer the proper type to use with this method; you will
            /// usually need to specify it explicitly.  i.e.
            /// `return_const(42i32)` instead of `return_const(42)`.
            #[allow(unused_variables)]
            pub(in super::super) fn return_const<MockallOutput>(
                &mut self,
                __mockall_c: MockallOutput,
            ) -> &mut Self
            where
                MockallOutput: Clone + Into<()> + Send + 'static,
            {
                self.returning(move |a, b, c, d, e, f, g| __mockall_c.clone().into())
            }
            /// Single-threaded version of
            /// [`return_const`](#method.return_const).  This is useful for
            /// return types that are not `Send`.
            ///
            /// The output type must be `Clone`.  The compiler can't always
            /// infer the proper type to use with this method; you will
            /// usually need to specify it explicitly.  i.e.
            /// `return_const(42i32)` instead of `return_const(42)`.
            ///
            /// It is a runtime error to call the mock method from a
            /// different thread than the one that originally called this
            /// method.
            #[allow(unused_variables)]
            pub(in super::super) fn return_const_st<MockallOutput>(
                &mut self,
                __mockall_c: MockallOutput,
            ) -> &mut Self
            where
                MockallOutput: Clone + Into<()> + 'static,
            {
                self.returning_st(move |a, b, c, d, e, f, g| __mockall_c.clone().into())
            }
            /// Supply an `FnOnce` closure that will provide the return
            /// value for this Expectation.  This is useful for return types
            /// that aren't `Clone`.  It will be an error to call this
            /// method multiple times.
            pub(in super::super) fn return_once<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Self
            where
                MockallF: FnOnce((), (), (), (), (), (), ()) -> () + Send + 'static,
            {
                {
                    let mut __mockall_guard = self.rfunc.lock().unwrap();
                    *__mockall_guard.deref_mut() = Rfunc::Once(Box::new(__mockall_f));
                }
                self
            }
            /// Single-threaded version of
            /// [`return_once`](#method.return_once).  This is useful for
            /// return types that are neither `Send` nor `Clone`.
            ///
            /// It is a runtime error to call the mock method from a
            /// different thread than the one that originally called this
            /// method.  It is also a runtime error to call the method more
            /// than once.
            pub(in super::super) fn return_once_st<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Self
            where
                MockallF: FnOnce((), (), (), (), (), (), ()) -> () + 'static,
            {
                {
                    let mut __mockall_guard = self.rfunc.lock().unwrap();
                    *__mockall_guard
                        .deref_mut() = Rfunc::OnceSt(
                        ::mockall::Fragile::new(Box::new(__mockall_f)),
                    );
                }
                self
            }
            /// Supply a closure that will provide the return value for this
            /// `Expectation`.  The method's arguments are passed to the
            /// closure by value.
            pub(in super::super) fn returning<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Self
            where
                MockallF: FnMut((), (), (), (), (), (), ()) -> () + Send + 'static,
            {
                {
                    let mut __mockall_guard = self.rfunc.lock().unwrap();
                    *__mockall_guard.deref_mut() = Rfunc::Mut(Box::new(__mockall_f));
                }
                self
            }
            /// Single-threaded version of [`returning`](#method.returning).
            /// Can be used when the argument or return type isn't `Send`.
            ///
            /// It is a runtime error to call the mock method from a
            /// different thread than the one that originally called this
            /// method.
            pub(in super::super) fn returning_st<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Self
            where
                MockallF: FnMut((), (), (), (), (), (), ()) -> () + 'static,
            {
                {
                    let mut __mockall_guard = self.rfunc.lock().unwrap();
                    *__mockall_guard
                        .deref_mut() = Rfunc::MutSt(
                        ::mockall::Fragile::new(Box::new(__mockall_f)),
                    );
                }
                self
            }
            /// Add this expectation to a
            /// [`Sequence`](../../../mockall/struct.Sequence.html).
            pub(in super::super) fn in_sequence(
                &mut self,
                __mockall_seq: &mut ::mockall::Sequence,
            ) -> &mut Self {
                self.common.in_sequence(__mockall_seq);
                self
            }
            fn is_done(&self) -> bool {
                self.common.is_done()
            }
            /// Validate this expectation's matcher.
            #[allow(clippy::ptr_arg)]
            fn matches(
                &self,
                a: &(),
                b: &(),
                c: &(),
                d: &(),
                e: &(),
                f: &(),
                g: &(),
            ) -> bool {
                self.common.matches(a, b, c, d, e, f, g)
            }
            /// Forbid this expectation from ever being called.
            pub(in super::super) fn never(&mut self) -> &mut Self {
                self.common.never();
                self
            }
            /// Create a new, default, [`Expectation`](struct.Expectation.html)
            pub(in super::super) fn new() -> Self {
                Self::default()
            }
            /// Expect this expectation to be called exactly once.  Shortcut for
            /// [`times(1)`](#method.times).
            pub(in super::super) fn once(&mut self) -> &mut Self {
                self.times(1)
            }
            /// Restrict the number of times that that this method may be called.
            ///
            /// The argument may be:
            /// * A fixed number: `.times(4)`
            /// * Various types of range:
            ///   - `.times(5..10)`
            ///   - `.times(..10)`
            ///   - `.times(5..)`
            ///   - `.times(5..=10)`
            ///   - `.times(..=10)`
            /// * The wildcard: `.times(..)`
            pub(in super::super) fn times<MockallR>(
                &mut self,
                __mockall_r: MockallR,
            ) -> &mut Self
            where
                MockallR: Into<::mockall::TimesRange>,
            {
                self.common.times(__mockall_r);
                self
            }
            /// Set matching crieteria for this Expectation.
            ///
            /// The matching predicate can be anything implemening the
            /// [`Predicate`](../../../mockall/trait.Predicate.html) trait.  Only
            /// one matcher can be set per `Expectation` at a time.
            pub(in super::super) fn with<
                MockallMatcher0: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher1: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher2: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher3: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher4: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher5: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher6: ::mockall::Predicate<()> + Send + 'static,
            >(
                &mut self,
                a: MockallMatcher0,
                b: MockallMatcher1,
                c: MockallMatcher2,
                d: MockallMatcher3,
                e: MockallMatcher4,
                f: MockallMatcher5,
                g: MockallMatcher6,
            ) -> &mut Self {
                self.common.with(a, b, c, d, e, f, g);
                self
            }
            /// Set a matching function for this Expectation.
            ///
            /// This is equivalent to calling [`with`](#method.with) with a
            /// function argument, like `with(predicate::function(f))`.
            pub(in super::super) fn withf<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Self
            where
                MockallF: Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + Send + 'static,
            {
                self.common.withf(__mockall_f);
                self
            }
            /// Single-threaded version of [`withf`](#method.withf).
            /// Can be used when the argument type isn't `Send`.
            pub(in super::super) fn withf_st<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Self
            where
                MockallF: Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + 'static,
            {
                self.common.withf_st(__mockall_f);
                self
            }
        }
        impl Default for Expectation {
            fn default() -> Self {
                Expectation {
                    common: Common::default(),
                    rfunc: Mutex::new(Rfunc::default()),
                }
            }
        }
        /// A collection of [`Expectation`](struct.Expectations.html)
        /// objects.  Users will rarely if ever use this struct directly.
        #[doc(hidden)]
        pub(in super::super) struct Expectations(Vec<Expectation>);
        impl Expectations {
            /// Verify that all current expectations are satisfied and clear
            /// them.
            pub(in super::super) fn checkpoint(
                &mut self,
            ) -> std::vec::Drain<Expectation> {
                self.0.drain(..)
            }
            /// Create a new expectation for this method.
            pub(in super::super) fn expect(&mut self) -> &mut Expectation {
                self.0.push(Expectation::default());
                let __mockall_l = self.0.len();
                &mut self.0[__mockall_l - 1]
            }
            pub(in super::super) fn new() -> Self {
                Self::default()
            }
        }
        impl Default for Expectations {
            fn default() -> Self {
                Expectations(Vec::new())
            }
        }
        impl Expectations {
            /// Simulate calling the real method.  Every current expectation
            /// will be checked in FIFO order and the first one with
            /// matching arguments will be used.
            pub(in super::super) fn call(
                &self,
                a: (),
                b: (),
                c: (),
                d: (),
                e: (),
                f: (),
                g: (),
            ) -> Option<()> {
                self.0
                    .iter()
                    .find(|__mockall_e| {
                        __mockall_e.matches(&a, &b, &c, &d, &e, &f, &g)
                            && (!__mockall_e.is_done() || self.0.len() == 1)
                    })
                    .map(move |__mockall_e| __mockall_e.call(a, b, c, d, e, f, g))
            }
        }
        #[allow(missing_copy_implementations)]
        #[allow(non_camel_case_types)]
        #[allow(dead_code)]
        #[doc(hidden)]
        pub(in super::super) struct EXPECTATIONS {
            __private_field: (),
        }
        #[doc(hidden)]
        pub(in super::super) static EXPECTATIONS: EXPECTATIONS = EXPECTATIONS {
            __private_field: (),
        };
        impl ::lazy_static::__Deref for EXPECTATIONS {
            type Target = ::std::sync::Mutex<Expectations>;
            fn deref(&self) -> &::std::sync::Mutex<Expectations> {
                #[inline(always)]
                fn __static_ref_initialize() -> ::std::sync::Mutex<Expectations> {
                    ::std::sync::Mutex::new(Expectations::new())
                }
                #[inline(always)]
                fn __stability() -> &'static ::std::sync::Mutex<Expectations> {
                    static LAZY: ::lazy_static::lazy::Lazy<
                        ::std::sync::Mutex<Expectations>,
                    > = ::lazy_static::lazy::Lazy::INIT;
                    LAZY.get(__static_ref_initialize)
                }
                __stability()
            }
        }
        impl ::lazy_static::LazyStatic for EXPECTATIONS {
            fn initialize(lazy: &Self) {
                let _ = &**lazy;
            }
        }
        /// Like an [`&Expectation`](struct.Expectation.html) but
        /// protected by a Mutex guard.  Useful for mocking static
        /// methods.  Forwards accesses to an `Expectation` object.
        pub(in super::super) struct ExpectationGuard<'__mockall_lt> {
            guard: MutexGuard<'__mockall_lt, Expectations>,
            i: usize,
        }
        #[allow(clippy::unused_unit)]
        impl<'__mockall_lt> ExpectationGuard<'__mockall_lt> {
            #[doc(hidden)]
            pub(in super::super) fn new(
                mut __mockall_guard: MutexGuard<'__mockall_lt, Expectations>,
            ) -> Self {
                __mockall_guard.expect();
                let __mockall_i = __mockall_guard.0.len() - 1;
                ExpectationGuard {
                    guard: __mockall_guard,
                    i: __mockall_i,
                }
            }
            /// Just like
            /// [`Expectation::in_sequence`](struct.Expectation.html#method.in_sequence)
            pub(in super::super) fn in_sequence(
                &mut self,
                __mockall_seq: &mut ::mockall::Sequence,
            ) -> &mut Expectation {
                self.guard.0[self.i].in_sequence(__mockall_seq)
            }
            /// Just like
            /// [`Expectation::never`](struct.Expectation.html#method.never)
            pub(in super::super) fn never(&mut self) -> &mut Expectation {
                self.guard.0[self.i].never()
            }
            /// Just like
            /// [`Expectation::once`](struct.Expectation.html#method.once)
            pub(in super::super) fn once(&mut self) -> &mut Expectation {
                self.guard.0[self.i].once()
            }
            /// Just like
            /// [`Expectation::return_const`](struct.Expectation.html#method.return_const)
            pub(in super::super) fn return_const<MockallOutput>(
                &mut self,
                __mockall_c: MockallOutput,
            ) -> &mut Expectation
            where
                MockallOutput: Clone + Into<()> + Send + 'static,
            {
                self.guard.0[self.i].return_const(__mockall_c)
            }
            /// Just like
            /// [`Expectation::return_const_st`](struct.Expectation.html#method.return_const_st)
            pub(in super::super) fn return_const_st<MockallOutput>(
                &mut self,
                __mockall_c: MockallOutput,
            ) -> &mut Expectation
            where
                MockallOutput: Clone + Into<()> + 'static,
            {
                self.guard.0[self.i].return_const_st(__mockall_c)
            }
            /// Just like
            /// [`Expectation::returning`](struct.Expectation.html#method.returning)
            pub(in super::super) fn returning<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Expectation
            where
                MockallF: FnMut((), (), (), (), (), (), ()) -> () + Send + 'static,
            {
                self.guard.0[self.i].returning(__mockall_f)
            }
            /// Just like
            /// [`Expectation::return_once`](struct.Expectation.html#method.return_once)
            pub(in super::super) fn return_once<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Expectation
            where
                MockallF: FnOnce((), (), (), (), (), (), ()) -> () + Send + 'static,
            {
                self.guard.0[self.i].return_once(__mockall_f)
            }
            /// Just like
            /// [`Expectation::return_once_st`](struct.Expectation.html#method.return_once_st)
            pub(in super::super) fn return_once_st<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Expectation
            where
                MockallF: FnOnce((), (), (), (), (), (), ()) -> () + 'static,
            {
                self.guard.0[self.i].return_once_st(__mockall_f)
            }
            /// Just like
            /// [`Expectation::returning_st`](struct.Expectation.html#method.returning_st)
            pub(in super::super) fn returning_st<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Expectation
            where
                MockallF: FnMut((), (), (), (), (), (), ()) -> () + 'static,
            {
                self.guard.0[self.i].returning_st(__mockall_f)
            }
            /// Just like
            /// [`Expectation::times`](struct.Expectation.html#method.times)
            pub(in super::super) fn times<MockallR>(
                &mut self,
                __mockall_r: MockallR,
            ) -> &mut Expectation
            where
                MockallR: Into<::mockall::TimesRange>,
            {
                self.guard.0[self.i].times(__mockall_r)
            }
            /// Just like
            /// [`Expectation::with`](struct.Expectation.html#method.with)
            pub(in super::super) fn with<
                MockallMatcher0: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher1: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher2: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher3: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher4: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher5: ::mockall::Predicate<()> + Send + 'static,
                MockallMatcher6: ::mockall::Predicate<()> + Send + 'static,
            >(
                &mut self,
                a: MockallMatcher0,
                b: MockallMatcher1,
                c: MockallMatcher2,
                d: MockallMatcher3,
                e: MockallMatcher4,
                f: MockallMatcher5,
                g: MockallMatcher6,
            ) -> &mut Expectation {
                self.guard.0[self.i].with(a, b, c, d, e, f, g)
            }
            /// Just like
            /// [`Expectation::withf`](struct.Expectation.html#method.withf)
            pub(in super::super) fn withf<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Expectation
            where
                MockallF: Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + Send + 'static,
            {
                self.guard.0[self.i].withf(__mockall_f)
            }
            /// Just like
            /// [`Expectation::withf_st`](struct.Expectation.html#method.withf_st)
            pub(in super::super) fn withf_st<MockallF>(
                &mut self,
                __mockall_f: MockallF,
            ) -> &mut Expectation
            where
                MockallF: Fn(&(), &(), &(), &(), &(), &(), &()) -> bool + 'static,
            {
                self.guard.0[self.i].withf_st(__mockall_f)
            }
        }
        /// Manages the context for expectations of static methods.
        ///
        /// Expectations on this method will be validated and cleared when
        /// the `Context` object drops.  The `Context` object does *not*
        /// provide any form of synchronization, so multiple tests that set
        /// expectations on the same static method must provide their own.
        #[must_use = "Context only serves to create expectations"]
        pub(in super::super) struct Context {
            _phantom: ::std::marker::PhantomData<Box<dyn Fn() + Send>>,
        }
        impl Context {
            /// Verify that all current expectations for this method are
            /// satisfied and clear them.
            pub(in super::super) fn checkpoint(&self) {
                Self::do_checkpoint()
            }
            #[doc(hidden)]
            pub(in super::super) fn do_checkpoint() {
                let __mockall_timeses = EXPECTATIONS
                    .lock()
                    .unwrap()
                    .checkpoint()
                    .collect::<Vec<_>>();
            }
            /// Create a new expectation for this method.
            #[must_use = "Must set return value when not using the \"nightly\" feature"]
            pub(in super::super) fn expect<'__mockall_lt>(
                &self,
            ) -> ExpectationGuard<'__mockall_lt> {
                ExpectationGuard::new(EXPECTATIONS.lock().unwrap())
            }
        }
        impl Default for Context {
            fn default() -> Self {
                Context {
                    _phantom: std::marker::PhantomData,
                }
            }
        }
        impl Drop for Context {
            fn drop(&mut self) {
                Self::do_checkpoint()
            }
        }
    }
}
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
#[allow(missing_docs)]
pub struct MockFoo {}
impl ::std::fmt::Debug for MockFoo {
    fn fmt(
        &self,
        f: &mut ::std::fmt::Formatter<'_>,
    ) -> ::std::result::Result<(), std::fmt::Error> {
        f.debug_struct("MockFoo").finish()
    }
}
impl ::std::default::Default for MockFoo {
    #[allow(clippy::default_trait_access)]
    fn default() -> Self {
        Self {}
    }
}
impl MockFoo {
    #[allow(dead_code)]
    fn bar(a: (), b: (), c: (), d: (), e: (), f: (), g: ()) {
        let no_match_msg = {
            let res = ::alloc::fmt::format(
                format_args!(
                    "{0}: No matching expectation found", { let res =
                    ::alloc::fmt::format(format_args!("MockFoo::bar({0:?}, {1:?}, {2:?}, {3:?}, {4:?}, {5:?}, {6:?})",
                    ::mockall::MaybeDebugger(& a), ::mockall::MaybeDebugger(& b),
                    ::mockall::MaybeDebugger(& c), ::mockall::MaybeDebugger(& d),
                    ::mockall::MaybeDebugger(& e), ::mockall::MaybeDebugger(& f),
                    ::mockall::MaybeDebugger(& g))); res }
                ),
            );
            res
        };
        {
            let __mockall_guard = __mock_MockFoo::__bar::EXPECTATIONS.lock().unwrap();
            __mockall_guard.call(a, b, c, d, e, f, g)
        }
            .expect(&no_match_msg)
    }
    ///Create a [`Context`](__mock_MockFoo/__bar/struct.Context.html) for mocking the `bar` method
    fn bar_context() -> __mock_MockFoo::__bar::Context {
        __mock_MockFoo::__bar::Context::default()
    }
    /// Validate that all current expectations for all methods have
    /// been satisfied, and discard them.
    pub fn checkpoint(&mut self) {}
    /// Create a new mock object with no expectations.
    ///
    /// This method will not be generated if the real struct
    /// already has a `new` method.  However, it *will* be
    /// generated if the struct implements a trait with a `new`
    /// method.  The trait's `new` method can still be called
    /// like `<MockX as TraitY>::new`
    pub fn new() -> Self {
        Self::default()
    }
}

[asomers]

I mean, don't you need to add a #![allow(clippy::too_many_arguments)] yourself to suppress that warning on the regular object instead of the mock one?

[RickySyndica]

I've worked out the issue. The generated code takes &self or &mut self whereas the original method doesn't. So in the generated code, there's the 7 original parameters, plus 1 more for self, hence triggering the clippy warning

[asomers]

Ahh, so this is only really an issue when mocking static functions with exactly 7 arguments?

[RickySyndica]

Yes, exactly. I didn't realise the issue was so specific when I first made the issue, so apologies for the lack of detail

[RickySyndica]

Thanks for fixing this!