go/types gets this right, which further confirms your thinking:

f.go:10:11: I((*T)(nil)) (value of type I) is not constant

Thank you for reporting this @mundaym

/cc @mdempsky @griesemer

Smaller repro:

package p

type I interface{ F() }
type T struct{}

const _ = I(T{})

func (T) F() {}

The issue seems to stem from how gc is designed. Reading main.go, I see how it typechecks nodes in phases:

// Phase 1: const, type, and names and types of funcs.
[...]
// Phase 2: Variable assignments.

So it seems to me like a possible fix would be to insert an extra phase before "variable assignments" called "constant declarations". That way, in our example above, func (T) F() would always be typechecked before const _ = I(T{}).

@griesemer @mdempsky thoughts? Is there a better way to fix this issue? (Edit: ended up sending this as a CL - see below)

I guess that another potential fix would be to detect if we're in phase 1 in the typechecker, and avoid giving errors like missing F method. After all, there is no guarantee that all methods have been typechecked and added to their respective types until we're past that phase. But it seems like special-casing all these errors would be a game of whack-a-mole.

Change https://golang.org/cl/115096 mentions this issue: cmd/compile: typecheck types and funcs before consts

Let's leave this alone for 1.11. It's more subtle that it seems (see my comments on the issue) and it's definitively not urgent.

Sorry I missed this issue and CL until now.

I'm not convinced the committed fix fully addresses this. Typechecking package-scope declarations can't really be split into phases; there's always a way to construct code that depends on any particular kind of declaration being typechecked before any other.

E.g., this test case still repros the issue:

package p

import "unsafe"

type x [unsafe.Sizeof(w)]int

type I interface{ F() }
type T struct{}

const w = I(T{})

func (T) F() {}

(And as a more superficial issue, there are now two phase "3"s in main.go.)

@mdempsky Agreed, I have also mentioned this in the CL (but the quick test case I tried to create didn't produce an error - see my CL feedback).

Simpler repro (no need for "unsafe"), same error besides otherwise being incorrect:

package p

type x [w]int

type I interface{ F() }
type T struct{}

const w = I(T{})

func (T) F() {}

I'm going to roll back the change.

Change https://golang.org/cl/145617 mentions this issue: cmd/compile: revert "typecheck types and funcs before consts"

For what it's worth, while simply typechecking var/type/func declarations separately from const declarations doesn't work, I think the idea I sketched in #13890 to separate package-scope typechecking into "type resolution" and "constant evaluation" phases would work here.

Thanks for the follow-up - looking forward to seeing what a better fix would be like :)

Too late for 1.12.

Not sure when this got fixed but the Go playground example now gives the correct error message. Closing this.

I don't think it does? I'm still seeing the wrong error message ("does not implement") at https://play.golang.org/p/jzbFN6k7Jhk.

Sorry, yes you're right, I looked at the wrong link.