I tried to produce a simpler example but this works:

type a[T interface { type [2]int, [3]int }] T

func main() {
	var dummy a[[3]int]
	const c = len(dummy)
}

https://go2goplay.golang.org/p/bpK6OWMpRVN

I'm not sure what the difference but this allowed a workaround.

I tested this again with Go1.18 beta1 and the problem is still there. It only seems to happen with type parameters on a function not a type. I know I found a workaround for what I was trying, but I think this code should still compile:

func f[T [3]int](dummy T) {
	const c = len(dummy)
}

but instead it gives the error: len(dummy) (value of type int) is not constant

$ go1.18beta1 version
go version go1.18beta1 windows/amd64

The (forthcoming) spec doesn't say that len for a type parameter value is constant - no matter how the type parameter is constrained.

A generic function must be compilable without instantiation; i.e., the body must type-check without knowledge of how the function is called. For a value a of type parameter P where P is constrained by (pointer to) array types, len(a) could be constant if and only if all those arrays have the same length. In any other case, len(a) cannot be constant because we don't know which array type the type parameter is instantiated with. But if all those arrays have the same length, we know the length, and we could just use it directly.

(Perhaps we still want to change the implementation if it simplifies the rules - but it's in no way important. See also #50226.)

The case of a generic type is a bit different: A generic type cannot be used without instantiation, and once it is instantiated it is a non-generic type. So if you instantiate the type with an array, after instantiation that array is known and len will do what it always did.

Thus, this is working as (currently) intended, pending decision on #50226.