All-new Derive syntax

[asomers]

Mockall is a great crate that's used by lots of projects, but its syntax isn't perfect. It reflects language limitations, historical implementation details, and the legacies of its predecessors. In particular, it has a few oft-noted problems:

• #[automock] doesn't work on structs with more than one trait impl, or structs with both a trait impl and inherent methods.
• It's hard to pass extra information to mockall to tweak the generated code. Currently, the only way to do this is by:
  • Metaitems, used for associated types: #[automock(type Key=u16; type Value=i32;)], but this would get cumbersome if Mockall ever supports more types of metaitems.
  • The #[concretize] attribute, but its implementation is hacky.

Instead, I propose replacing all of Mockall's syntax with a new Derive macro, which would solve both of these problems. The first, it would solve by generating the code in pieces. The second, it would solve by standard helper attributes. Its syntax would look like this:

// For traits
#[derive(Mock)]
pub trait Foo {
    #[mockall::as(u32)]
    type Address;
    fn foo(&self, a: Self::Address);

    #[mockall::concretize]
    fn bar<T>(&self, t: T) -> u32;
}

// For structs
#[derive(Mock)]
#[mockall::trait_impls(Iterator)]
struct Foo {
    fn foo(&self) {
        // ...
    }
}
#[derive(Mock)]
impl Iterator for Foo {
    type Item = u32;
    fn next(&mut self) -> Option<Self::Item> {
        // ...
    }
}

With this syntax, mock! would only be necesary when mocking structs or traits from external traits. Also, it would be easy to add more helper attributes. For example:

• #[concretize], which already exists
• #[as], for mocking traits with associated constants
• #[skip], as discussed in Support returning of generic parameter using mock! macro #536, Skip Generating mock methods #471, and Warning: mocked function never used #410
• Something to help with async methods, as discussed in Use async function in something like returning #252 and Allow expectation on async trait function to return a future #189
• #[default] to make a method return a default value, so you won't have to do
  something like .return_const(()) everywhere.
• #[expect_name(something)], which would allow implementing multiple traits
  whose methods have the same names, as discussed in How to mock multiple impls of generic struct instances? #271.

I doubt I'll hear any objections to these new features, so what remains is mainly a question of deciding how to name things. That and, of course, finding the time to implement it all ;)

[Michaelschnabel-DM]

Hi, any update on this?

[asomers]

I got it almost all working. It was actually surprisingly easy. But there was one nasty case that I couldn't solve. In fact, Mockall's currently generated code for that case is arguably incorrect. There was no obvious solution, so I haven't worked on it for months.

You can see the test cases that don't work here:

• https://github.com/asomers/mockall/blob/multi-automock2/mockall/tests/automock_specific_impl.rs
• https://github.com/asomers/mockall/blob/multi-automock2/mockall/tests/automock_same_trait_twice_on_generic_struct.rs