cmd/compile: invalidly inferred type for interface that doesn't use type parameter

[griesemer]

In the following code:

type T[P any] interface {
	m()
}

func g[P any](T[P]) {}

func _() {
	var x T[int]
	g(x)         // here we infer P == int, but in fact any type of P would be ok
	g[string](x) // here we set P == string
}

we infer the type int for P of g. But in fact any type would make this code work. Type inference should not succeed in this case.

[jimmyfrasche]

I'm not sure I follow.

In my mind

• unifying P = int is correct because that's what x is
• g[string](x) should be an error because string ≠ int

That P is not currently used by T does not seem relevant. Say you allow g[string] but then in a later version T is updated to

type T[P any] interface {
	m() P
}

now g[string] is an error and the correct inference would be int but the only thing that changed was an implementation detail

[griesemer]

Consider this case:

type T1[P any] interface {
	m()
}

type T2[P any] interface {
	m()
}

func g[P any](T1[P]) {}

func _() {
	var x T2[int]
	g(x)         // here we infer P == int, but in fact any type of P would be ok
	g[string](x) // here we set P == string
}

Now we get an error for g(x) but g[string](x) is ok. That seems inconsistent. We should not be able to infer a type for P in the first case.

[jimmyfrasche]

I see what you are saying. The interfaces-as-constraints are identical to each other and interface { m() } so P does not matter for the constraint.

However, it seems like the parameterization of the interface-as-type should still be part of its identity.

[atdiar]

@jimmyfrasche that's why it's inference which would fail.

But not instantiation.

[jimmyfrasche]

I expect it to behave like this, since the interface(s) aren't used as constraints and are just ordinary types:

type T[P any] struct{}

func g[P any](T[P]) {}

func _() {
	var x T[int]
	g(x)         // here we infer P == int
	g[string](x) // here we fail to set P == string as P = int
}

https://go.dev/play/p/0Wj38UCOijw

[griesemer]

@jimmyfrasche But the rules for interface assignment are quite different from non-interface assignment. But here is a counter-example:

type T[P any] interface{ m() }

func g[P any](func(T[P])) {}

func _() {
	var f func(T[int])
	g(f)
	g[int](f)
	g[string](f) // ERROR cannot use f (variable of type func(T[int])) as func(T[string]) value in argument to g[string]
}

Because the interface is a component type, now it must match exactly.