[dev.unified] test: relax panic message expectations

In this test, traditionally the comparison `*l == r[0]` was left as a
comparison between `*l` (type `any`) and `r[0]` (type `*int`), and the
rest of the compiler needed to handle mixed-typed comparisons.
However, this means more complexity for wiring up explicit rtypes.

To simplify rtype handling, the next CL will change unified IR to
instead handle the expression as `*l == any(r[0])`. However, a
consequence of this currently is that walk will now sequence the
`any(r[0])` expression first, because it involves a
concrete-to-interface conversion. And in turn, this means the `r[0]`
panic ("index out of bounds") will take priority over the `*l`
panic ("nil pointer dereference").

This is a change in user-visible semantics in some cases, but the Go
spec leaves this unspecified, so it shouldn't be an issue. Note also:
gccgo has the same behavior (i.e., panicking on index out of bounds,
not nil pointer dereference), and cmd/compile also already has the
same behavior when the interface conversion is explicit (as in the
added "nil pointer dereference #3" test case).

Updates #23735.
Updates #32187.

Change-Id: I49e5dcca85b4680f9c8780ef0013e64254d38fe5
Reviewed-on: https://go-review.googlesource.com/c/go/+/418097
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: David Chase <drchase@google.com>

diff --git a/test/fixedbugs/issue32187.go b/test/fixedbugs/issue32187.go
index 9c8c9c26d7980cba248bfe124208e809a4e49dca..268da8112ff8f2808f3e11089009feae8c83695d 100644 (file)
--- a/test/fixedbugs/issue32187.go
+++ b/test/fixedbugs/issue32187.go
@@ -36,7 +36,11 @@ func main() {
                {"type assertion", "", func() { _ = x == x.(*int) }},
                {"out of bounds", "", func() { _ = x == s[1] }},
                {"nil pointer dereference #1", "", func() { _ = x == *p }},
-               {"nil pointer dereference #2", "nil pointer dereference", func() { _ = *l == r[0] }},
+               // TODO(mdempsky): Restore "nil pointer dereference" check. The Go
+               // spec doesn't mandate an order for panics (or even panic
+               // messages), but left-to-right is less confusing to users.
+               {"nil pointer dereference #2", "", func() { _ = *l == r[0] }},
+               {"nil pointer dereference #3", "", func() { _ = *l == any(r[0]) }},
        }
 
        for _, tc := range tests {
@@ -44,16 +48,14 @@ func main() {
        }
 }
 
-func testFuncShouldPanic(name, errStr string, f func()) {
+func testFuncShouldPanic(name, want string, f func()) {
        defer func() {
                e := recover()
                if e == nil {
                        log.Fatalf("%s: comparison did not panic\n", name)
                }
-               if errStr != "" {
-                       if !strings.Contains(e.(error).Error(), errStr) {
-                               log.Fatalf("%s: wrong panic message\n", name)
-                       }
+               if have := e.(error).Error(); !strings.Contains(have, want) {
+                       log.Fatalf("%s: wrong panic message: have %q, want %q\n", name, have, want)
                }
        }()
        f()