package main

import (
	"fmt"
)

type EmptyInterface interface {
	type interface{}
}

func Return(type T EmptyInterface, T2 T)(x T2) T2 {
	return x
}

func main() {
	fmt.Println(Return(interface{}, interface{})(0))
}

is valid.

Return is instantiated with two empty interfaces as types. First, the type parameters T and T2 are substituted leading to the type parameter signature (type interface{} EmptyInterface, interface{} interface{}). Then we check constraints: interface{} is a type that's in the type list of EmptyInterface, and the 2nd interface{} implements its constraint which is interface{}. So the instantiation is valid. Now we check the argument passing: x is of type interface{}, and we can assign a 0 to it. The result is of type interface{} and contains the int value 0. LGTM!

package main

import (
	"fmt"
	"syscall"
)

type Stringy interface {
	type fmt.Stringer, error
}

func Return(type T Stringy, T2 T)(x T2) T2 {
	return x
}

func main() {
	fmt.Println(Return(error, syscall.Errno)(syscall.ENOSYS))
}

is valid and the error is incorrect.

Return is instantiated with T = error, and T2 = syscall.Errno. Then we check constraints: error must satisfy Stringy which it does because there's no methods but error is in the type list. syscall.Errno must satisfy error (because T was substituted with error), which it does because syscall.Errno implements error.

Edited: Upon further reflection (and looking at the implementation), I believe this program should be considered incorrect: A function is always type-checked independent of instantiation (it may be exported and we don't know where it is used). For Return to be correct, the constraint for T2 must be an interface, but it is type parameter T which may or may not be an interface. Now in this case, the constraint for T is Stringy which enumerates two interfaces in its type list. Therefore one could argue that T is known to be an interface, eventually. But that seems really pushing it. In any case, the current prototype would require some significant changes (constraints are expected to be interfaces early on).

2nd edit: It's more complicated than that: Sometimes this actually works, e.g. in this case:

func _(type A interface{ type interface{} }, B A)()

So there are some open issues here.

I'd say the result here is a question: Should this be permitted or not? I suggest that it be left out; it could always be added if it were important.

The last program

package main

import (
	"fmt"
	"syscall"
)

type Stringy interface {
	type interface{ Error() string }, interface{ String() string }
}

func Return(type T Stringy, T2 T)(x T2) T2 {
	return x
}

func main() {
	fmt.Println(Return(error, syscall.Errno)(syscall.ENOSYS))
}

is valid (same reasons as before) and the error message is incorrect (the reason is that the interface are compared before they are "completed" and then they look the same).

In summary, the last two programs shouldn't produce an error, but the first one is correct (and actually runs).

Correction: The first program is correct, the 2nd one (likely) incorrect per the current design (see edited comment above), and the last program is correct and shouldn't report an error.

Change https://golang.org/cl/239158 mentions this issue: [dev.go2go] go/types: check for duplicate types after interfaces were completed

Fixed error for last program on dev.go2go. Filed separate issue #39723 for 2nd program. Closing.