Oh, the issue is because of this short-circuit in mapaccess1:

    if h == nil || h.count == 0 {
            return unsafe.Pointer(&zeroVal[0])
    }

If m is a non-nil non-empty map, the index expression panics.

We could call alg.hash(key, 0) or alg.equal(k, k) inside that short circuit. I'm not sure if this would be worth fixing though. It seems very unlikely that anyone is depending on this behavior.

alg.hash(k, 0) would be better, because it'll give the same "hash of unhashable type" panic that non-empty maps would raise; alg.equal(k, k) would instead raise "comparing uncomparable type".

That said, I'd expect hash lookups into nil and empty maps might be pretty common, so it'd be desirable to skip the hash operation if possible? The compiler could add another flag to maptype (like reflexivekey) to indicate whether key values are always comparable.

Same for delete

package main

func main() {
	 var m = map[interface{}]int{}
	 var i interface{} = []int{}
	 delete(m, i)
}

Change https://golang.org/cl/155918 mentions this issue: runtime: panic on uncomparable map key, even if map is empty