Mockgen: Support generating mock for interfaces with generics

[lingyv-li]

Requested feature

Mockgen should support generating mocks for interfaces with generics.

Why the feature is needed
The Go 1.18 is planned to be released soon, and I noticed that the mockgen tool doesn't support the generic. When a type parameter is in the interface, mockgen will throw an error.

Code example: https://go.dev/play/p/g1G2OvZPQpT?v=gotip

> go run github.com/golang/mock/mockgen -source=generic_mock.go
2022/02/13 10:59:41 Loading input failed: don't know how to mock method of type *ast.IndexExpr
exit status 1

(Optional) Proposed solution

1. In the code example above, the StudentRepository interface is concrete, so the gererated mock should be concrete too with the type parameters substituted.
2. The BaseRepository interface is abstract, so the generated mock struct should also have the same type parameters.

(My use case only needs 1, which mockery supports as of today.)

[CannibalVox]

In fact, I've gotten errors generating mocks for interfaces that don't use generics but are located in packages that do use generics. So I think this might be a slightly more serious issue than it appears at first glance.

[codyoss]

Hey, this is planned and will try to land as a fast followup to 1.18. Thank you for the request!

[abramk]

Do you have a rough idea of when we can expect a generics compatible release? This is the main impediment for us to aggressively adopt generic goodness.

[CannibalVox]

FWIW I was able to work around the above issue by moving interfaces out to their own file that don't use generics. That doesn't help for cases where you want the interface itself to use generics, but it did help for my case.

[anjmao]

Haven't looked into Go generics yet, but shouldn't it be possible to rewrite mock with generics and remove the need to generate mocks code?

I imagine it could be similar to C# moq.

service := gomock.New[MyServiceInterface]()
service.EXPECT().GetItem(gomock.Any).Returns(item, nil)

[abramk]

I don't believe the above is possible with go generics. The code has no way of reflecting on the type of the actual parameter. @codyoss do you have an idea of when we can expect generics support?

[powerman]

Looks like it's possible to work around this issue by using type aliases:

// Broken:
type Target interface {
    Method() *generic.Type[int]
}

// Working:
type GenericTypeInt = generic.Type[int]
type Target interface {
    Method() *GenericTypeInt
}

[swallowtail62]

@powerman
It works for me. thank you.

[sodul]

@codyoss Now that Go 1.18 has been out for over a month, is there a timeline update you can share? Thank you!

[bradleygore]

The solution proposed by @powerman doesn't work for generics working with custom types from what I can see:

// generic thing in foo pkg
type Gen [T any] struct {
  Items []T
  // other fields
}

// package bar

import "path/to/foo"

type Thing struct {
  FirstName string
}

type GenericTypeGenThing = foo.Gen[*Thing]

// interface I want to generate a mock for
type Thinger interface {
  Get() GenericTypeGenThing
}

What I see happening is that the generated output is like this for the generic return parameter: foo.Gen[*path/to/bar.Thing]

[powerman]

What I see happening is that the generated output is like this for the generic return parameter: foo.Gen[*path/to/bar.Thing]

At a glance there is a typo in your example code, this line probably should be:

type GenericTypeGenThing = foo.Gen[*Thing] // Added "foo." here.

Unlikely this is the actual problem, because without "foo." it shouldn't compile at all. Anyway, working example in some temp repo would be useful to understand why workaround doesn't works for you.

[bradleygore]

Yeah, that's a typo but not the issue. As you said, it wouldn't have compiled if that were the issue. That's what I get for hastily making a contrived example based on the real one 😝

I appreciate your looking into it!