gc: disallow map/func equality via interface comparison

Missed when I removed direct map/func equality.

R=ken2
CC=golang-dev
https://golang.org/cl/5452052

diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 8bdfaf7b0cc768da0c4afcee91a7af4b581c13f6..5584f78e2f9a150fc3296eecc2e092e166426706 100644 (file)
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -499,8 +499,7 @@ algtype(Type *t)
 {
        int a;
 
-       if(issimple[t->etype] || isptr[t->etype] ||
-               t->etype == TCHAN || t->etype == TFUNC || t->etype == TMAP) {
+       if(issimple[t->etype] || isptr[t->etype] || t->etype == TCHAN) {
                if(t->width == 1)
                        a = AMEM8;
                else if(t->width == 2)

diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go
index a9e5d1cade4dfec83625798db6cd93a7a344b305..e43260196fe72a4d18a9ec34551116e1d0671a1b 100644 (file)
--- a/src/pkg/reflect/all_test.go
+++ b/src/pkg/reflect/all_test.go
@@ -468,8 +468,8 @@ func TestInterfaceValue(t *testing.T) {
 func TestFunctionValue(t *testing.T) {
        var x interface{} = func() {}
        v := ValueOf(x)
-       if v.Interface() != v.Interface() || v.Interface() != x {
-               t.Fatalf("TestFunction != itself")
+       if fmt.Sprint(v.Interface()) != fmt.Sprint(x) {
+               t.Fatalf("TestFunction returned wrong pointer")
        }
        assert(t, v.Type().String(), "func()")
 }

diff --git a/test/interface/noeq.go b/test/interface/noeq.go
new file mode 100644 (file)
index 0000000..be36821
--- /dev/null
+++ b/test/interface/noeq.go
@@ -0,0 +1,39 @@
+// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: interface/noeq
+
+// Copyright 2011 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Interface values containing types that cannot be compared for equality.
+
+package main
+
+func main() {
+       cmp(1)
+       
+       var (
+               m map[int]int
+               s struct{}
+               f func()
+       )
+       noCmp(m)
+       noCmp(s)
+       noCmp(f)
+}
+
+func cmp(x interface{}) bool {
+       return x == x
+}
+
+func noCmp(x interface{}) {
+       shouldPanic(func() { cmp(x) })
+}
+
+func shouldPanic(f func()) {
+       defer func() {
+               if recover() == nil {
+                       panic("function should panic")
+               }
+       }()
+       f()
+}