diff options
Diffstat (limited to 'test')
99 files changed, 3101 insertions, 367 deletions
diff --git a/test/bench/shootout/timing.log b/test/bench/shootout/timing.log index ee1f889b4..4e7d17a11 100644 --- a/test/bench/shootout/timing.log +++ b/test/bench/shootout/timing.log @@ -1161,3 +1161,94 @@ chameneos 6000000 gccgo -O2 chameneosredux.go 11.28u 6.68s 18.00r gc chameneosredux 6.94u 0.00s 6.96r +# May 23, 2013 +# Go 1.1, which includes precise GC, new scheduler, faster maps. +# 20%-ish speedups across many benchmarks. +# gccgo showing significant improvement (even though it's not yet up to Go 1.1) +# +# Standouts: +# fannkuch, regex-dna, k-nucleotide, threadring, chameneos + +fasta -n 25000000 + gcc -m64 -O2 fasta.c 1.54u 0.01s 1.55r + gccgo -O2 fasta.go 1.42u 0.00s 1.43r + gc fasta 1.50u 0.01s 1.52r # -16% + gc_B fasta 1.46u 0.00s 1.46r # -17% + +reverse-complement < output-of-fasta-25000000 + gcc -m64 -O2 reverse-complement.c 0.87u 0.37s 4.36r + gccgo -O2 reverse-complement.go 0.77u 0.15s 0.93r # -15% + gc reverse-complement 0.99u 0.12s 1.12r # -15% + gc_B reverse-complement 0.85u 0.17s 1.02r # -21% + +nbody -n 50000000 + gcc -m64 -O2 nbody.c -lm 13.50u 0.00s 13.53r + gccgo -O2 nbody.go 13.98u 0.01s 14.02r + gc nbody 16.63u 0.01s 16.67r + gc_B nbody 15.74u 0.00s 15.76r + +binary-tree 15 # too slow to use 20 + gcc -m64 -O2 binary-tree.c -lm 0.61u 0.00s 0.61r + gccgo -O2 binary-tree.go 1.11u 0.01s 1.12r # -13% + gccgo -O2 binary-tree-freelist.go 0.22u 0.01s 0.23r + gc binary-tree 1.83u 0.02s 1.83r # -7% + gc binary-tree-freelist 0.32u 0.00s 0.32r + +fannkuch 12 + gcc -m64 -O2 fannkuch.c 45.56u 0.00s 45.67r + gccgo -O2 fannkuch.go 57.71u 0.00s 57.85r # -4% + gccgo -O2 fannkuch-parallel.go 146.31u 0.00s 37.50r #-37% + gc fannkuch 70.06u 0.03s 70.17r # -3% + gc fannkuch-parallel 131.88u 0.06s 33.59r # -23% + gc_B fannkuch 45.55u 0.02s 45.63r # -15% + +regex-dna 100000 + gcc -m64 -O2 regex-dna.c -lpcre 0.44u 0.01s 0.45r + gccgo -O2 regex-dna.go 5.59u 0.00s 5.61r # -14% + gccgo -O2 regex-dna-parallel.go 10.85u 0.30s 3.34r # -24% + gc regex-dna 2.23u 0.01s 2.25r # -43% + gc regex-dna-parallel 2.35u 0.00s 0.93r # -40% + gc_B regex-dna 2.24u 0.01s 2.25r # -43% + +spectral-norm 5500 + gcc -m64 -O2 spectral-norm.c -lm 14.84u 0.00s 14.88r + gccgo -O2 spectral-norm.go 15.33u 0.00s 15.37r + gc spectral-norm 16.75u 0.02s 16.79r # -15% + gc_B spectral-norm 16.77u 0.01s 16.79r # -15% + +k-nucleotide 1000000 + gcc -O2 k-nucleotide.c -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include -lglib-2.0 4.50u 0.00s 4.52r + gccgo -O2 k-nucleotide.go 3.72u 0.04s 3.77r # -21% + gccgo -O2 k-nucleotide-parallel.go 3.88u 0.03s 1.42r # -35% + gc k-nucleotide 6.32u 0.01s 6.33r # -31% + gc k-nucleotide-parallel 6.47u 0.05s 2.13r # -33% + gc_B k-nucleotide 6.45u 0.01s 6.47r # - 28% + +mandelbrot 16000 + gcc -m64 -O2 mandelbrot.c 36.03u 0.00s 36.11r + gccgo -O2 mandelbrot.go 37.61u 0.00s 37.74r # -14% + gc mandelbrot 38.19u 0.05s 38.29r + gc_B mandelbrot 38.19u 0.03s 38.26r + +meteor 2098 + gcc -m64 -O2 meteor-contest.c 0.08u 0.00s 0.08r + gccgo -O2 meteor-contest.go 0.09u 0.01s 0.10r + gc meteor-contest 0.12u 0.00s 0.12r # -15% although perhaps just noise + gc_B meteor-contest 0.11u 0.00s 0.12r # -8% although perhaps just noise + +pidigits 10000 + gcc -m64 -O2 pidigits.c -lgmp 2.27u 0.00s 2.28r + gccgo -O2 pidigits.go 8.95u 0.02s 8.99r + gc pidigits 2.88u 0.14s 2.91r + gc_B pidigits 2.92u 0.10s 2.91r + +threadring 50000000 + gcc -m64 -O2 threadring.c -lpthread 14.75u 167.88s 212.23r + gccgo -O2 threadring.go 36.72u 12.08s 48.91r # -29% + gc threadring 10.93u 0.01s 10.95r # -16% + +chameneos 6000000 + gcc -m64 -O2 chameneosredux.c -lpthread 8.89u 56.62s 9.75r + gccgo -O2 chameneosredux.go 9.48u 2.48s 11.99r # -33% + gc chameneosredux 5.80u 0.00s 5.81r # -16% + diff --git a/test/blank.go b/test/blank.go index 7f7d9f6f7..0539debb1 100644 --- a/test/blank.go +++ b/test/blank.go @@ -27,6 +27,10 @@ func (T) _() { func (T) _() { } +type U struct { + _ struct{ a, b, c int } +} + const ( c0 = iota _ @@ -107,8 +111,7 @@ func main() { panic(sum) } - // exp/ssa/interp doesn't yet skip blank fields in struct - // equivalence. It also cannot support unsafe.Pointer. + // go.tools/ssa/interp cannot support unsafe.Pointer. if os.Getenv("GOSSAINTERP") == "" { type T1 struct{ x, y, z int } t1 := *(*T)(unsafe.Pointer(&T1{1, 2, 3})) @@ -116,6 +119,13 @@ func main() { if t1 != t2 { panic("T{} != T{}") } + + var u1, u2 interface{} + u1 = *(*U)(unsafe.Pointer(&T1{1, 2, 3})) + u2 = *(*U)(unsafe.Pointer(&T1{4, 5, 6})) + if u1 != u2 { + panic("U{} != U{}") + } } h(a, b) diff --git a/test/blank1.go b/test/blank1.go index 4edb2db70..54a72976b 100644 --- a/test/blank1.go +++ b/test/blank1.go @@ -13,9 +13,16 @@ var t struct { _ int } +type T struct { + _ []int +} + func main() { _() // ERROR "cannot use _ as value" x := _+1 // ERROR "cannot use _ as value" _ = x - _ = t._ // ERROR "cannot refer to blank field" + _ = t._ // ERROR "cannot refer to blank field|invalid use of" + + var v1, v2 T + _ = v1 == v2 // ERROR "cannot be compared|non-comparable" } diff --git a/test/chan/doubleselect.go b/test/chan/doubleselect.go index ac559302d..6be3faf55 100644 --- a/test/chan/doubleselect.go +++ b/test/chan/doubleselect.go @@ -36,7 +36,7 @@ func sender(n int, c1, c2, c3, c4 chan<- int) { } // mux receives the values from sender and forwards them onto another channel. -// It would be simplier to just have sender's four cases all be the same +// It would be simpler to just have sender's four cases all be the same // channel, but this doesn't actually trigger the bug. func mux(out chan<- int, in <-chan int, done chan<- bool) { for v := range in { diff --git a/test/chan/select2.go b/test/chan/select2.go index 4a0813912..ccf9dab81 100644 --- a/test/chan/select2.go +++ b/test/chan/select2.go @@ -47,7 +47,8 @@ func main() { runtime.GC() runtime.ReadMemStats(memstats) - if memstats.Alloc-alloc > 1.1e5 { + // Be careful to avoid wraparound. + if memstats.Alloc > alloc && memstats.Alloc-alloc > 1.1e5 { println("BUG: too much memory for 100,000 selects:", memstats.Alloc-alloc) } } diff --git a/test/cmp.go b/test/cmp.go index 5be64561d..73de502f3 100644 --- a/test/cmp.go +++ b/test/cmp.go @@ -43,8 +43,8 @@ func main() { var d string = "hel" // try to get different pointer d = d + "lo" - // exp/ssa/interp can't handle unsafe.Pointer. - if os.Getenv("GOSSAINTERP") != "" { + // go.tools/ssa/interp can't handle unsafe.Pointer. + if os.Getenv("GOSSAINTERP") == "" { if stringptr(c) == stringptr(d) { panic("compiler too smart -- got same string") } @@ -296,7 +296,7 @@ func main() { { var x = struct { x int - _ []int + _ string y float64 _ float64 z int diff --git a/test/cmp6.go b/test/cmp6.go index 7d99aae18..839c274bc 100644 --- a/test/cmp6.go +++ b/test/cmp6.go @@ -53,7 +53,7 @@ func main() { // Comparison of structs should have a good message use(t3 == t3) // ERROR "struct|expected" - use(t4 == t4) // ok; the []int is a blank field + use(t4 == t4) // ERROR "cannot be compared|non-comparable" // Slices, functions, and maps too. var x []int diff --git a/test/const6.go b/test/const6.go index c04435db6..c005ac369 100644 --- a/test/const6.go +++ b/test/const6.go @@ -19,12 +19,12 @@ var ( c4 mybool = c2 == (1 < 2) c5 mybool = 1 < 2 c6 mybool1 = x < y - c7 = c1 == c2 // ERROR "mismatched types" - c8 = c2 == c6 // ERROR "mismatched types" - c9 = c1 == c6 // ERROR "mismatched types" + c7 = c1 == c2 // ERROR "mismatched types|incompatible types" + c8 = c2 == c6 // ERROR "mismatched types|incompatible types" + c9 = c1 == c6 // ERROR "mismatched types|incompatible types" _ = c2 && (x < y) _ = c2 && (1 < 2) - _ = c1 && c2 // ERROR "mismatched types" - _ = c2 && c6 // ERROR "mismatched types" - _ = c1 && c6 // ERROR "mismatched types" + _ = c1 && c2 // ERROR "mismatched types|incompatible types" + _ = c2 && c6 // ERROR "mismatched types|incompatible types" + _ = c1 && c6 // ERROR "mismatched types|incompatible types" ) diff --git a/test/deferfin.go b/test/deferfin.go new file mode 100644 index 000000000..f9a74eba9 --- /dev/null +++ b/test/deferfin.go @@ -0,0 +1,59 @@ +// run + +// Copyright 2013 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. + +// Test that defers do not prevent garbage collection. + +package main + +import ( + "runtime" + "sync" + "sync/atomic" + "time" +) + +var sink func() + +func main() { + // Does not work on 32-bits due to partially conservative GC. + // Try to enable when we have fully precise GC. + if runtime.GOARCH != "amd64" { + return + } + N := 10 + count := int32(N) + var wg sync.WaitGroup + wg.Add(N) + for i := 0; i < N; i++ { + go func() { + defer wg.Done() + v := new(int) + f := func() { + if *v != 0 { + panic("oops") + } + } + if *v != 0 { + // let the compiler think f escapes + sink = f + } + runtime.SetFinalizer(v, func(p *int) { + atomic.AddInt32(&count, -1) + }) + defer f() + }() + } + wg.Wait() + for i := 0; i < 3; i++ { + time.Sleep(10 * time.Millisecond) + runtime.GC() + } + if count != 0 { + println(count, "out of", N, "finalizer are not called") + panic("not all finalizers are called") + } +} + diff --git a/test/divmod.go b/test/divmod.go new file mode 100644 index 000000000..49fed0222 --- /dev/null +++ b/test/divmod.go @@ -0,0 +1,460 @@ +// run + +// Copyright 2013 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. + +// Test division of variables. Generate many test cases, +// compute correct answer using shift and subtract, +// and then compare against results from divison and +// modulus operators. +// +// Primarily useful for testing software div/mod. + +package main + +const long = false + +func main() { + if long { + // About 3e9 test cases (calls to checkdiv3). + // Too long for everyday testing. + gen2(3, 64, 2, 64, checkdiv1) + println(ntest) + } else { + // About 4e6 test cases (calls to checkdiv3). + // Runs for 8 seconds on ARM chromebook, much faster elsewhere. + gen2(2, 64, 1, 64, checkdiv1) + } +} + +// generate all uint64 values x where x has at most n bits set in the low w +// and call f(x) for each. +func gen1(n, w int, f func(uint64)) { + gen(0, 0, n, w-1, f) +} + +func gen(val uint64, nbits, maxbits, pos int, f func(uint64)) { + if pos < 0 { + f(val) + return + } + gen(val, nbits, maxbits, pos-1, f) + if nbits < maxbits { + gen(val|1<<uint(pos), nbits+1, maxbits, pos-1, f) + } +} + +// generate all uint64 values x, y where x has at most n1 bits set in the low w1 +// and y has at most n2 bits set in the low w2 and call f(x, y) for each. +func gen2(n1, w1, n2, w2 int, f func(uint64, uint64)) { + gen1(n1, w1, func(x uint64) { + gen1(n2, w2, func(y uint64) { + f(x, y) + }) + }) +} + +// x and y are uint64s with at most 2 bits set. +// Check those values and values above and below, +// along with bitwise inversions of the same (done in checkdiv2). +func checkdiv1(x, y uint64) { + checkdiv2(x, y) + // If the low bit is set in x or y, adding or subtracting 1 + // produces a number that checkdiv1 is going to be called + // with anyway, so don't duplicate effort. + if x&1 == 0 { + checkdiv2(x+1, y) + checkdiv2(x-1, y) + } + if y&1 == 0 { + checkdiv2(x, y-1) + checkdiv2(x, y+1) + if x&1 == 0 { + checkdiv2(x+1, y-1) + checkdiv2(x-1, y-1) + checkdiv2(x-1, y+1) + checkdiv2(x+1, y+1) + } + } +} + +func checkdiv2(x, y uint64) { + checkdiv3(x, y) + checkdiv3(^x, y) + checkdiv3(x, ^y) + checkdiv3(^x, ^y) +} + +var ntest int64 = 0 + +func checkdiv3(x, y uint64) { + ntest++ + if ntest&(ntest-1) == 0 && long { + println(ntest, "...") + } + checkuint64(x, y) + if (uint64(uint32(x)) == x || uint64(uint32(^x)) == ^x) && (uint64(uint32(y)) == y || uint64(uint32(^y)) == ^y) { + checkuint32(uint32(x), uint32(y)) + } + if (uint64(uint16(x)) == x || uint64(uint16(^x)) == ^x) && (uint64(uint16(y)) == y || uint64(uint16(^y)) == ^y) { + checkuint16(uint16(x), uint16(y)) + } + if (uint64(uint8(x)) == x || uint64(uint8(^x)) == ^x) && (uint64(uint8(y)) == y || uint64(uint8(^y)) == ^y) { + checkuint8(uint8(x), uint8(y)) + } + + + sx := int64(x) + sy := int64(y) + checkint64(sx, sy) + if (int64(int32(sx)) == sx || int64(int32(^sx)) == ^sx) && (int64(int32(sy)) == sy || int64(int32(^sy)) == ^sy) { + checkint32(int32(sx), int32(sy)) + } + if (int64(int16(sx)) == sx || int64(int16(^sx)) == ^sx) && (int64(int16(sy)) == sy || int64(int16(^sy)) == ^sy) { + checkint16(int16(sx), int16(sy)) + } + if (int64(int8(sx)) == sx || int64(int8(^sx)) == ^sx) && (int64(int8(sy)) == sy || int64(int8(^sy)) == ^sy) { + checkint8(int8(sx), int8(sy)) + } +} + +// Check result of x/y, x%y for various types. + +func checkuint(x, y uint) { + if y == 0 { + divzerouint(x, y) + modzerouint(x, y) + return + } + q, r := udiv(uint64(x), uint64(y)) + q1 := x/y + r1 := x%y + if q1 != uint(q) { + print("uint(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != uint(r) { + print("uint(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkuint64(x, y uint64) { + if y == 0 { + divzerouint64(x, y) + modzerouint64(x, y) + return + } + q, r := udiv(x, y) + q1 := x/y + r1 := x%y + if q1 != q { + print("uint64(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != r { + print("uint64(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkuint32(x, y uint32) { + if y == 0 { + divzerouint32(x, y) + modzerouint32(x, y) + return + } + q, r := udiv(uint64(x), uint64(y)) + q1 := x/y + r1 := x%y + if q1 != uint32(q) { + print("uint32(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != uint32(r) { + print("uint32(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkuint16(x, y uint16) { + if y == 0 { + divzerouint16(x, y) + modzerouint16(x, y) + return + } + q, r := udiv(uint64(x), uint64(y)) + q1 := x/y + r1 := x%y + if q1 != uint16(q) { + print("uint16(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != uint16(r) { + print("uint16(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkuint8(x, y uint8) { + if y == 0 { + divzerouint8(x, y) + modzerouint8(x, y) + return + } + q, r := udiv(uint64(x), uint64(y)) + q1 := x/y + r1 := x%y + if q1 != uint8(q) { + print("uint8(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != uint8(r) { + print("uint8(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkint(x, y int) { + if y == 0 { + divzeroint(x, y) + modzeroint(x, y) + return + } + q, r := idiv(int64(x), int64(y)) + q1 := x/y + r1 := x%y + if q1 != int(q) { + print("int(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != int(r) { + print("int(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkint64(x, y int64) { + if y == 0 { + divzeroint64(x, y) + modzeroint64(x, y) + return + } + q, r := idiv(x, y) + q1 := x/y + r1 := x%y + if q1 != q { + print("int64(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != r { + print("int64(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkint32(x, y int32) { + if y == 0 { + divzeroint32(x, y) + modzeroint32(x, y) + return + } + q, r := idiv(int64(x), int64(y)) + q1 := x/y + r1 := x%y + if q1 != int32(q) { + print("int32(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != int32(r) { + print("int32(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkint16(x, y int16) { + if y == 0 { + divzeroint16(x, y) + modzeroint16(x, y) + return + } + q, r := idiv(int64(x), int64(y)) + q1 := x/y + r1 := x%y + if q1 != int16(q) { + print("int16(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != int16(r) { + print("int16(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func checkint8(x, y int8) { + if y == 0 { + divzeroint8(x, y) + modzeroint8(x, y) + return + } + q, r := idiv(int64(x), int64(y)) + q1 := x/y + r1 := x%y + if q1 != int8(q) { + print("int8(", x, "/", y, ") = ", q1, ", want ", q, "\n") + } + if r1 != int8(r) { + print("int8(", x, "%", y, ") = ", r1, ", want ", r, "\n") + } +} + +func divzerouint(x, y uint) uint { + defer checkudivzero("uint", uint64(x)) + return x / y +} + +func divzerouint64(x, y uint64) uint64 { + defer checkudivzero("uint64", uint64(x)) + return x / y +} + +func divzerouint32(x, y uint32) uint32 { + defer checkudivzero("uint32", uint64(x)) + return x / y +} + +func divzerouint16(x, y uint16) uint16 { + defer checkudivzero("uint16", uint64(x)) + return x / y +} + +func divzerouint8(x, y uint8) uint8 { + defer checkudivzero("uint8", uint64(x)) + return x / y +} + +func checkudivzero(typ string, x uint64) { + if recover() == nil { + print(typ, "(", x, " / 0) did not panic") + } +} + +func divzeroint(x, y int) int { + defer checkdivzero("int", int64(x)) + return x / y +} + +func divzeroint64(x, y int64) int64 { + defer checkdivzero("int64", int64(x)) + return x / y +} + +func divzeroint32(x, y int32) int32 { + defer checkdivzero("int32", int64(x)) + return x / y +} + +func divzeroint16(x, y int16) int16 { + defer checkdivzero("int16", int64(x)) + return x / y +} + +func divzeroint8(x, y int8) int8 { + defer checkdivzero("int8", int64(x)) + return x / y +} + +func checkdivzero(typ string, x int64) { + if recover() == nil { + print(typ, "(", x, " / 0) did not panic") + } +} + +func modzerouint(x, y uint) uint { + defer checkumodzero("uint", uint64(x)) + return x % y +} + +func modzerouint64(x, y uint64) uint64 { + defer checkumodzero("uint64", uint64(x)) + return x % y +} + +func modzerouint32(x, y uint32) uint32 { + defer checkumodzero("uint32", uint64(x)) + return x % y +} + +func modzerouint16(x, y uint16) uint16 { + defer checkumodzero("uint16", uint64(x)) + return x % y +} + +func modzerouint8(x, y uint8) uint8 { + defer checkumodzero("uint8", uint64(x)) + return x % y +} + +func checkumodzero(typ string, x uint64) { + if recover() == nil { + print(typ, "(", x, " % 0) did not panic") + } +} + +func modzeroint(x, y int) int { + defer checkmodzero("int", int64(x)) + return x % y +} + +func modzeroint64(x, y int64) int64 { + defer checkmodzero("int64", int64(x)) + return x % y +} + +func modzeroint32(x, y int32) int32 { + defer checkmodzero("int32", int64(x)) + return x % y +} + +func modzeroint16(x, y int16) int16 { + defer checkmodzero("int16", int64(x)) + return x % y +} + +func modzeroint8(x, y int8) int8 { + defer checkmodzero("int8", int64(x)) + return x % y +} + +func checkmodzero(typ string, x int64) { + if recover() == nil { + print(typ, "(", x, " % 0) did not panic") + } +} + +// unsigned divide and mod using shift and subtract. +func udiv(x, y uint64) (q, r uint64) { + sh := 0 + for y+y > y && y+y <= x { + sh++ + y <<= 1 + } + for ; sh >= 0; sh-- { + q <<= 1 + if x >= y { + x -= y + q |= 1 + } + y >>= 1 + } + return q, x +} + +// signed divide and mod: do unsigned and adjust signs. +func idiv(x, y int64) (q, r int64) { + // special case for minint / -1 = minint + if x-1 > x && y == -1 { + return x, 0 + } + ux := uint64(x) + uy := uint64(y) + if x < 0 { + ux = -ux + } + if y < 0 { + uy = -uy + } + uq, ur := udiv(ux, uy) + q = int64(uq) + r = int64(ur) + if x < 0 { + r = -r + } + if (x < 0) != (y < 0) { + q = -q + } + return q, r +} diff --git a/test/errchk b/test/errchk index b8b312a92..de0c4fd2f 100755 --- a/test/errchk +++ b/test/errchk @@ -1,4 +1,4 @@ -#!/usr/bin/perl +#!/usr/bin/env perl # Copyright 2009 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. diff --git a/test/escape2.go b/test/escape2.go index 511b74a1c..be89c2d84 100644 --- a/test/escape2.go +++ b/test/escape2.go @@ -1136,6 +1136,7 @@ func foo126() { px = &i // ERROR "&i escapes" }() } + _ = px } var px *int @@ -1325,3 +1326,34 @@ func foo142() { t := new(Tm) // ERROR "escapes to heap" gf = t.M // ERROR "t.M escapes to heap" } + +// issue 3888. +func foo143() { + for i := 0; i < 1000; i++ { + func() { // ERROR "func literal does not escape" + for i := 0; i < 1; i++ { + var t Tm + t.M() // ERROR "t does not escape" + } + }() + } +} + +// issue 5773 +// Check that annotations take effect regardless of whether they +// are before or after the use in the source code. + +//go:noescape + +func foo144a(*int) + +func foo144() { + var x int + foo144a(&x) // ERROR "&x does not escape" + var y int + foo144b(&y) // ERROR "&y does not escape" +} + +//go:noescape + +func foo144b(*int) diff --git a/test/escape5.go b/test/escape5.go index 6b327fe9e..c9646872d 100644 --- a/test/escape5.go +++ b/test/escape5.go @@ -142,3 +142,10 @@ func f9() { var j T1 // ERROR "moved to heap: j" f8(&j) // ERROR "&j escapes to heap" } + +func f10() { + // These don't escape but are too big for the stack + var x [1<<30]byte // ERROR "moved to heap: x" + var y = make([]byte, 1<<30) // ERROR "does not escape" + _ = x[0] + y[0] +} diff --git a/test/fixedbugs/bug086.go b/test/fixedbugs/bug086.go index f03982b30..40d236206 100644 --- a/test/fixedbugs/bug086.go +++ b/test/fixedbugs/bug086.go @@ -6,12 +6,12 @@ package main -func f() int { // GCCGO_ERROR "control" +func f() int { if false { return 0; } // we should not be able to return successfully w/o a return statement -} // GC_ERROR "return" +} // ERROR "return" func main() { print(f(), "\n"); diff --git a/test/fixedbugs/bug205.go b/test/fixedbugs/bug205.go index 769837d04..1e0d9d1f3 100644 --- a/test/fixedbugs/bug205.go +++ b/test/fixedbugs/bug205.go @@ -11,8 +11,8 @@ var s string; var m map[string]int; func main() { - println(t["hi"]); // ERROR "non-integer slice index" - println(s["hi"]); // ERROR "non-integer string index" - println(m[0]); // ERROR "as type string in map index" + println(t["hi"]); // ERROR "non-integer slice index|must be integer" + println(s["hi"]); // ERROR "non-integer string index|must be integer" + println(m[0]); // ERROR "cannot use.*as type string" } diff --git a/test/fixedbugs/bug295.go b/test/fixedbugs/bug295.go index e2e5206ca..63a12a3a7 100644 --- a/test/fixedbugs/bug295.go +++ b/test/fixedbugs/bug295.go @@ -6,7 +6,9 @@ package main -import . "testing" // defines top-level T +import . "testing" // defines file-level T + +type _ B // make use of package "testing" (but don't refer to T) type S struct { T int diff --git a/test/fixedbugs/bug385_64.go b/test/fixedbugs/bug385_64.go index b5621b210..aef03c389 100644 --- a/test/fixedbugs/bug385_64.go +++ b/test/fixedbugs/bug385_64.go @@ -10,13 +10,214 @@ package main -func main() { // ERROR "stack frame too large" - var arr [1000200030]int32 - arr_bkup := arr - _ = arr_bkup -} +var z [10<<20]byte -func F() { // ERROR "stack frame too large" - var arr [1 << 30]int32 - _ = arr[42] +func main() { // ERROR "stack frame too large" + // seq 1 206 | sed 's/.*/ var x& [10<<20]byte; z = x&/' + var x1 [10<<20]byte; z = x1 + var x2 [10<<20]byte; z = x2 + var x3 [10<<20]byte; z = x3 + var x4 [10<<20]byte; z = x4 + var x5 [10<<20]byte; z = x5 + var x6 [10<<20]byte; z = x6 + var x7 [10<<20]byte; z = x7 + var x8 [10<<20]byte; z = x8 + var x9 [10<<20]byte; z = x9 + var x10 [10<<20]byte; z = x10 + var x11 [10<<20]byte; z = x11 + var x12 [10<<20]byte; z = x12 + var x13 [10<<20]byte; z = x13 + var x14 [10<<20]byte; z = x14 + var x15 [10<<20]byte; z = x15 + var x16 [10<<20]byte; z = x16 + var x17 [10<<20]byte; z = x17 + var x18 [10<<20]byte; z = x18 + var x19 [10<<20]byte; z = x19 + var x20 [10<<20]byte; z = x20 + var x21 [10<<20]byte; z = x21 + var x22 [10<<20]byte; z = x22 + var x23 [10<<20]byte; z = x23 + var x24 [10<<20]byte; z = x24 + var x25 [10<<20]byte; z = x25 + var x26 [10<<20]byte; z = x26 + var x27 [10<<20]byte; z = x27 + var x28 [10<<20]byte; z = x28 + var x29 [10<<20]byte; z = x29 + var x30 [10<<20]byte; z = x30 + var x31 [10<<20]byte; z = x31 + var x32 [10<<20]byte; z = x32 + var x33 [10<<20]byte; z = x33 + var x34 [10<<20]byte; z = x34 + var x35 [10<<20]byte; z = x35 + var x36 [10<<20]byte; z = x36 + var x37 [10<<20]byte; z = x37 + var x38 [10<<20]byte; z = x38 + var x39 [10<<20]byte; z = x39 + var x40 [10<<20]byte; z = x40 + var x41 [10<<20]byte; z = x41 + var x42 [10<<20]byte; z = x42 + var x43 [10<<20]byte; z = x43 + var x44 [10<<20]byte; z = x44 + var x45 [10<<20]byte; z = x45 + var x46 [10<<20]byte; z = x46 + var x47 [10<<20]byte; z = x47 + var x48 [10<<20]byte; z = x48 + var x49 [10<<20]byte; z = x49 + var x50 [10<<20]byte; z = x50 + var x51 [10<<20]byte; z = x51 + var x52 [10<<20]byte; z = x52 + var x53 [10<<20]byte; z = x53 + var x54 [10<<20]byte; z = x54 + var x55 [10<<20]byte; z = x55 + var x56 [10<<20]byte; z = x56 + var x57 [10<<20]byte; z = x57 + var x58 [10<<20]byte; z = x58 + var x59 [10<<20]byte; z = x59 + var x60 [10<<20]byte; z = x60 + var x61 [10<<20]byte; z = x61 + var x62 [10<<20]byte; z = x62 + var x63 [10<<20]byte; z = x63 + var x64 [10<<20]byte; z = x64 + var x65 [10<<20]byte; z = x65 + var x66 [10<<20]byte; z = x66 + var x67 [10<<20]byte; z = x67 + var x68 [10<<20]byte; z = x68 + var x69 [10<<20]byte; z = x69 + var x70 [10<<20]byte; z = x70 + var x71 [10<<20]byte; z = x71 + var x72 [10<<20]byte; z = x72 + var x73 [10<<20]byte; z = x73 + var x74 [10<<20]byte; z = x74 + var x75 [10<<20]byte; z = x75 + var x76 [10<<20]byte; z = x76 + var x77 [10<<20]byte; z = x77 + var x78 [10<<20]byte; z = x78 + var x79 [10<<20]byte; z = x79 + var x80 [10<<20]byte; z = x80 + var x81 [10<<20]byte; z = x81 + var x82 [10<<20]byte; z = x82 + var x83 [10<<20]byte; z = x83 + var x84 [10<<20]byte; z = x84 + var x85 [10<<20]byte; z = x85 + var x86 [10<<20]byte; z = x86 + var x87 [10<<20]byte; z = x87 + var x88 [10<<20]byte; z = x88 + var x89 [10<<20]byte; z = x89 + var x90 [10<<20]byte; z = x90 + var x91 [10<<20]byte; z = x91 + var x92 [10<<20]byte; z = x92 + var x93 [10<<20]byte; z = x93 + var x94 [10<<20]byte; z = x94 + var x95 [10<<20]byte; z = x95 + var x96 [10<<20]byte; z = x96 + var x97 [10<<20]byte; z = x97 + var x98 [10<<20]byte; z = x98 + var x99 [10<<20]byte; z = x99 + var x100 [10<<20]byte; z = x100 + var x101 [10<<20]byte; z = x101 + var x102 [10<<20]byte; z = x102 + var x103 [10<<20]byte; z = x103 + var x104 [10<<20]byte; z = x104 + var x105 [10<<20]byte; z = x105 + var x106 [10<<20]byte; z = x106 + var x107 [10<<20]byte; z = x107 + var x108 [10<<20]byte; z = x108 + var x109 [10<<20]byte; z = x109 + var x110 [10<<20]byte; z = x110 + var x111 [10<<20]byte; z = x111 + var x112 [10<<20]byte; z = x112 + var x113 [10<<20]byte; z = x113 + var x114 [10<<20]byte; z = x114 + var x115 [10<<20]byte; z = x115 + var x116 [10<<20]byte; z = x116 + var x117 [10<<20]byte; z = x117 + var x118 [10<<20]byte; z = x118 + var x119 [10<<20]byte; z = x119 + var x120 [10<<20]byte; z = x120 + var x121 [10<<20]byte; z = x121 + var x122 [10<<20]byte; z = x122 + var x123 [10<<20]byte; z = x123 + var x124 [10<<20]byte; z = x124 + var x125 [10<<20]byte; z = x125 + var x126 [10<<20]byte; z = x126 + var x127 [10<<20]byte; z = x127 + var x128 [10<<20]byte; z = x128 + var x129 [10<<20]byte; z = x129 + var x130 [10<<20]byte; z = x130 + var x131 [10<<20]byte; z = x131 + var x132 [10<<20]byte; z = x132 + var x133 [10<<20]byte; z = x133 + var x134 [10<<20]byte; z = x134 + var x135 [10<<20]byte; z = x135 + var x136 [10<<20]byte; z = x136 + var x137 [10<<20]byte; z = x137 + var x138 [10<<20]byte; z = x138 + var x139 [10<<20]byte; z = x139 + var x140 [10<<20]byte; z = x140 + var x141 [10<<20]byte; z = x141 + var x142 [10<<20]byte; z = x142 + var x143 [10<<20]byte; z = x143 + var x144 [10<<20]byte; z = x144 + var x145 [10<<20]byte; z = x145 + var x146 [10<<20]byte; z = x146 + var x147 [10<<20]byte; z = x147 + var x148 [10<<20]byte; z = x148 + var x149 [10<<20]byte; z = x149 + var x150 [10<<20]byte; z = x150 + var x151 [10<<20]byte; z = x151 + var x152 [10<<20]byte; z = x152 + var x153 [10<<20]byte; z = x153 + var x154 [10<<20]byte; z = x154 + var x155 [10<<20]byte; z = x155 + var x156 [10<<20]byte; z = x156 + var x157 [10<<20]byte; z = x157 + var x158 [10<<20]byte; z = x158 + var x159 [10<<20]byte; z = x159 + var x160 [10<<20]byte; z = x160 + var x161 [10<<20]byte; z = x161 + var x162 [10<<20]byte; z = x162 + var x163 [10<<20]byte; z = x163 + var x164 [10<<20]byte; z = x164 + var x165 [10<<20]byte; z = x165 + var x166 [10<<20]byte; z = x166 + var x167 [10<<20]byte; z = x167 + var x168 [10<<20]byte; z = x168 + var x169 [10<<20]byte; z = x169 + var x170 [10<<20]byte; z = x170 + var x171 [10<<20]byte; z = x171 + var x172 [10<<20]byte; z = x172 + var x173 [10<<20]byte; z = x173 + var x174 [10<<20]byte; z = x174 + var x175 [10<<20]byte; z = x175 + var x176 [10<<20]byte; z = x176 + var x177 [10<<20]byte; z = x177 + var x178 [10<<20]byte; z = x178 + var x179 [10<<20]byte; z = x179 + var x180 [10<<20]byte; z = x180 + var x181 [10<<20]byte; z = x181 + var x182 [10<<20]byte; z = x182 + var x183 [10<<20]byte; z = x183 + var x184 [10<<20]byte; z = x184 + var x185 [10<<20]byte; z = x185 + var x186 [10<<20]byte; z = x186 + var x187 [10<<20]byte; z = x187 + var x188 [10<<20]byte; z = x188 + var x189 [10<<20]byte; z = x189 + var x190 [10<<20]byte; z = x190 + var x191 [10<<20]byte; z = x191 + var x192 [10<<20]byte; z = x192 + var x193 [10<<20]byte; z = x193 + var x194 [10<<20]byte; z = x194 + var x195 [10<<20]byte; z = x195 + var x196 [10<<20]byte; z = x196 + var x197 [10<<20]byte; z = x197 + var x198 [10<<20]byte; z = x198 + var x199 [10<<20]byte; z = x199 + var x200 [10<<20]byte; z = x200 + var x201 [10<<20]byte; z = x201 + var x202 [10<<20]byte; z = x202 + var x203 [10<<20]byte; z = x203 + var x204 [10<<20]byte; z = x204 + var x205 [10<<20]byte; z = x205 + var x206 [10<<20]byte; z = x206 } diff --git a/test/fixedbugs/bug435.go b/test/fixedbugs/bug435.go index 9c30b143b..45323d8ee 100644 --- a/test/fixedbugs/bug435.go +++ b/test/fixedbugs/bug435.go @@ -12,4 +12,4 @@ package main func foo() { - bar(1, // ERROR "unexpected|missing|undefined" + bar(1, // ERROR "unexpected|missing|undefined"
\ No newline at end of file diff --git a/test/fixedbugs/bug459.go b/test/fixedbugs/bug459.go index 80abe5d51..014f2ef01 100644 --- a/test/fixedbugs/bug459.go +++ b/test/fixedbugs/bug459.go @@ -9,7 +9,7 @@ package flag -var commandLine = NewFlagSet() // ERROR "loop" +var commandLine = NewFlagSet() // ERROR "loop|depends upon itself" type FlagSet struct { } diff --git a/test/fixedbugs/bug460.dir/a.go b/test/fixedbugs/bug460.dir/a.go index 02a287b31..29049d9aa 100644 --- a/test/fixedbugs/bug460.dir/a.go +++ b/test/fixedbugs/bug460.dir/a.go @@ -6,4 +6,8 @@ package a type Foo struct { int + int8 + error + rune + byte } diff --git a/test/fixedbugs/bug460.dir/b.go b/test/fixedbugs/bug460.dir/b.go index 1868afe07..5c0a0c47e 100644 --- a/test/fixedbugs/bug460.dir/b.go +++ b/test/fixedbugs/bug460.dir/b.go @@ -9,6 +9,9 @@ import "./a" var x a.Foo func main() { - x.int = 20 // ERROR "unexported field" + x.int = 20 // ERROR "unexported field" + x.int8 = 20 // ERROR "unexported field" + x.error = nil // ERROR "unexported field" + x.rune = 'a' // ERROR "unexported field" + x.byte = 20 // ERROR "unexported field" } - diff --git a/test/fixedbugs/bug475.go b/test/fixedbugs/bug475.go new file mode 100644 index 000000000..1bd6fa35c --- /dev/null +++ b/test/fixedbugs/bug475.go @@ -0,0 +1,22 @@ +// compile + +// Copyright 2013 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. + +// Variable in enclosing function with same name as field in struct +// composite literal confused gccgo. + +package p + +type s1 struct { + f *s1 +} + +func F() { + var f *s1 + _ = func() { + _ = s1{f: nil} + } + _ = f +} diff --git a/test/fixedbugs/bug476.go b/test/fixedbugs/bug476.go new file mode 100644 index 000000000..4ea217404 --- /dev/null +++ b/test/fixedbugs/bug476.go @@ -0,0 +1,23 @@ +// compile + +// Copyright 2013 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. + +// Logical operation on named boolean type returns the same type, +// supporting an implicit convertion to an interface type. This used +// to crash gccgo. + +package p + +type B bool + +func (b B) M() {} + +type I interface { + M() +} + +func F(a, b B) I { + return a && b +} diff --git a/test/fixedbugs/bug477.go b/test/fixedbugs/bug477.go new file mode 100644 index 000000000..86289afa6 --- /dev/null +++ b/test/fixedbugs/bug477.go @@ -0,0 +1,34 @@ +// compile + +// Copyright 2013 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. + +// Test multiple identical unnamed structs with methods. This caused +// a compilation error with gccgo. + +package p + +type S1 struct{} + +func (s S1) M() {} + +type S2 struct { + F1 struct { + S1 + } + F2 struct { + S1 + } +} + +type I interface { + M() +} + +func F() { + var s2 S2 + var i1 I = s2.F1 + var i2 I = s2.F2 + _, _ = i1, i2 +} diff --git a/test/fixedbugs/bug478.dir/a.go b/test/fixedbugs/bug478.dir/a.go new file mode 100644 index 000000000..a40e454f9 --- /dev/null +++ b/test/fixedbugs/bug478.dir/a.go @@ -0,0 +1,9 @@ +// Copyright 2013 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. + +package p1 + +type S1 struct{} + +func (s S1) f() {} diff --git a/test/fixedbugs/bug478.dir/b.go b/test/fixedbugs/bug478.dir/b.go new file mode 100644 index 000000000..c0fdf1127 --- /dev/null +++ b/test/fixedbugs/bug478.dir/b.go @@ -0,0 +1,13 @@ +// Copyright 2013 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. + +package p2 + +import "./a" + +type S2 struct { + p1.S1 +} + +func (s S2) f() {} diff --git a/test/fixedbugs/bug478.go b/test/fixedbugs/bug478.go new file mode 100644 index 000000000..5e339e801 --- /dev/null +++ b/test/fixedbugs/bug478.go @@ -0,0 +1,10 @@ +// compiledir + +// Copyright 2013 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. + +// Using the same unexported name for a method as a method on an +// imported embedded type caused a gccgo compilation failure. + +package ignored diff --git a/test/fixedbugs/bug479.dir/a.go b/test/fixedbugs/bug479.dir/a.go new file mode 100644 index 000000000..5ff3bef1d --- /dev/null +++ b/test/fixedbugs/bug479.dir/a.go @@ -0,0 +1,15 @@ +// Copyright 2013 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. + +package p + +import "unsafe" + +type S2 struct {} + +const C = unsafe.Sizeof(S2{}) + +type S1 struct { + S2 +} diff --git a/test/fixedbugs/bug479.dir/b.go b/test/fixedbugs/bug479.dir/b.go new file mode 100644 index 000000000..a1b27b332 --- /dev/null +++ b/test/fixedbugs/bug479.dir/b.go @@ -0,0 +1,16 @@ +// Copyright 2013 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. + +package main + +import "./a" + +type S3 struct { + p.S1 +} + +func main() { + var i interface{} = S3{} + _ = i +} diff --git a/test/fixedbugs/bug479.go b/test/fixedbugs/bug479.go new file mode 100644 index 000000000..f8a0f93c7 --- /dev/null +++ b/test/fixedbugs/bug479.go @@ -0,0 +1,10 @@ +// rundir + +// Copyright 2013 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. + +// Gccgo was not consistent in deciding how to compare a struct type +// for equality, leading to an undefined symbol at link time. + +package ignored diff --git a/test/fixedbugs/issue3783.go b/test/fixedbugs/issue3783.go index 35df5d8f6..d7a4a2e8f 100644 --- a/test/fixedbugs/issue3783.go +++ b/test/fixedbugs/issue3783.go @@ -8,5 +8,5 @@ package foo var i int -func (*i) bar() // ERROR "not a type" +func (*i) bar() // ERROR "not a type|expected type" diff --git a/test/fixedbugs/issue3925.go b/test/fixedbugs/issue3925.go index 2f8786fc7..a62d4392e 100644 --- a/test/fixedbugs/issue3925.go +++ b/test/fixedbugs/issue3925.go @@ -12,12 +12,12 @@ package foo var _ = map[string]string{ "1": "2", - "3", "4", // ERROR "missing key" + "3", "4", // ERROR "missing key|must have keys" } var _ = []string{ "foo", "bar", - 20, // ERROR "cannot use" + 20, // ERROR "cannot use|incompatible type" } diff --git a/test/fixedbugs/issue4085a.go b/test/fixedbugs/issue4085a.go index 8a52b268f..089637d86 100644 --- a/test/fixedbugs/issue4085a.go +++ b/test/fixedbugs/issue4085a.go @@ -9,10 +9,10 @@ package main type T []int func main() { - _ = make(T, -1) // ERROR "negative" - _ = make(T, 0.5) // ERROR "constant 0.5 truncated to integer" - _ = make(T, 1.0) // ok - _ = make(T, 1<<63) // ERROR "len argument too large" - _ = make(T, 0, -1) // ERROR "negative cap" + _ = make(T, -1) // ERROR "negative" + _ = make(T, 0.5) // ERROR "constant 0.5 truncated to integer|non-integer len argument" + _ = make(T, 1.0) // ok + _ = make(T, 1<<63) // ERROR "len argument too large" + _ = make(T, 0, -1) // ERROR "negative cap" _ = make(T, 10, 0) // ERROR "len larger than cap" } diff --git a/test/fixedbugs/issue4097.go b/test/fixedbugs/issue4097.go index fa942c9db..c2b7d9b4f 100644 --- a/test/fixedbugs/issue4097.go +++ b/test/fixedbugs/issue4097.go @@ -7,5 +7,5 @@ package foo var s [][10]int -const m = len(s[len(s)-1]) // ERROR "is not a constant" +const m = len(s[len(s)-1]) // ERROR "is not a constant|is not constant" diff --git a/test/fixedbugs/issue4232.go b/test/fixedbugs/issue4232.go index 29ddfa8a9..e5daa6562 100644 --- a/test/fixedbugs/issue4232.go +++ b/test/fixedbugs/issue4232.go @@ -8,26 +8,26 @@ package p func f() { var a [10]int - _ = a[-1] // ERROR "invalid array index -1" - _ = a[-1:] // ERROR "invalid slice index -1" - _ = a[:-1] // ERROR "invalid slice index -1" - _ = a[10] // ERROR "invalid array index 10" + _ = a[-1] // ERROR "invalid array index -1|index out of bounds" + _ = a[-1:] // ERROR "invalid slice index -1|index out of bounds" + _ = a[:-1] // ERROR "invalid slice index -1|index out of bounds" + _ = a[10] // ERROR "invalid array index 10|index out of bounds" var s []int - _ = s[-1] // ERROR "invalid slice index -1" - _ = s[-1:] // ERROR "invalid slice index -1" - _ = s[:-1] // ERROR "invalid slice index -1" + _ = s[-1] // ERROR "invalid slice index -1|index out of bounds" + _ = s[-1:] // ERROR "invalid slice index -1|index out of bounds" + _ = s[:-1] // ERROR "invalid slice index -1|index out of bounds" _ = s[10] const c = "foo" - _ = c[-1] // ERROR "invalid string index -1" - _ = c[-1:] // ERROR "invalid slice index -1" - _ = c[:-1] // ERROR "invalid slice index -1" - _ = c[3] // ERROR "invalid string index 3" + _ = c[-1] // ERROR "invalid string index -1|index out of bounds" + _ = c[-1:] // ERROR "invalid slice index -1|index out of bounds" + _ = c[:-1] // ERROR "invalid slice index -1|index out of bounds" + _ = c[3] // ERROR "invalid string index 3|index out of bounds" var t string - _ = t[-1] // ERROR "invalid string index -1" - _ = t[-1:] // ERROR "invalid slice index -1" - _ = t[:-1] // ERROR "invalid slice index -1" + _ = t[-1] // ERROR "invalid string index -1|index out of bounds" + _ = t[-1:] // ERROR "invalid slice index -1|index out of bounds" + _ = t[:-1] // ERROR "invalid slice index -1|index out of bounds" _ = t[3] } diff --git a/test/fixedbugs/issue4251.go b/test/fixedbugs/issue4251.go index a14e0896a..4adec2bab 100644 --- a/test/fixedbugs/issue4251.go +++ b/test/fixedbugs/issue4251.go @@ -9,13 +9,13 @@ package p func F1(s []byte) []byte { - return s[2:1] // ERROR "inverted" + return s[2:1] // ERROR "invalid slice index" } func F2(a [10]byte) []byte { - return a[2:1] // ERROR "inverted" + return a[2:1] // ERROR "invalid slice index" } func F3(s string) string { - return s[2:1] // ERROR "inverted" + return s[2:1] // ERROR "invalid slice index" } diff --git a/test/fixedbugs/issue4452.go b/test/fixedbugs/issue4452.go index c75da9024..54dd214d6 100644 --- a/test/fixedbugs/issue4452.go +++ b/test/fixedbugs/issue4452.go @@ -9,5 +9,5 @@ package main func main() { - _ = [...]int(4) // ERROR "use of \[\.\.\.\] array outside of array literal" + _ = [...]int(4) // ERROR "\[\.\.\.\].*outside of array literal" } diff --git a/test/fixedbugs/issue4458.go b/test/fixedbugs/issue4458.go index 8ee3e879e..820f18cb8 100644 --- a/test/fixedbugs/issue4458.go +++ b/test/fixedbugs/issue4458.go @@ -16,5 +16,5 @@ func (T) foo() {} func main() { av := T{} pav := &av - (**T).foo(&pav) // ERROR "no method foo" + (**T).foo(&pav) // ERROR "no method foo|requires named type or pointer to named" } diff --git a/test/fixedbugs/issue4463.go b/test/fixedbugs/issue4463.go index fe07af71f..70977ceb7 100644 --- a/test/fixedbugs/issue4463.go +++ b/test/fixedbugs/issue4463.go @@ -45,17 +45,17 @@ func F() { (println("bar")) (recover()) - go append(a, 0) // ERROR "discards result" - go cap(a) // ERROR "discards result" - go complex(1, 2) // ERROR "discards result" - go imag(1i) // ERROR "discards result" - go len(a) // ERROR "discards result" - go make([]int, 10) // ERROR "discards result" - go new(int) // ERROR "discards result" - go real(1i) // ERROR "discards result" - go unsafe.Alignof(a) // ERROR "discards result" - go unsafe.Offsetof(s.f) // ERROR "discards result" - go unsafe.Sizeof(a) // ERROR "discards result" + go append(a, 0) // ERROR "not used|discards result" + go cap(a) // ERROR "not used|discards result" + go complex(1, 2) // ERROR "not used|discards result" + go imag(1i) // ERROR "not used|discards result" + go len(a) // ERROR "not used|discards result" + go make([]int, 10) // ERROR "not used|discards result" + go new(int) // ERROR "not used|discards result" + go real(1i) // ERROR "not used|discards result" + go unsafe.Alignof(a) // ERROR "not used|discards result" + go unsafe.Offsetof(s.f) // ERROR "not used|discards result" + go unsafe.Sizeof(a) // ERROR "not used|discards result" go close(c) go copy(a, a) @@ -65,17 +65,17 @@ func F() { go println("bar") go recover() - defer append(a, 0) // ERROR "discards result" - defer cap(a) // ERROR "discards result" - defer complex(1, 2) // ERROR "discards result" - defer imag(1i) // ERROR "discards result" - defer len(a) // ERROR "discards result" - defer make([]int, 10) // ERROR "discards result" - defer new(int) // ERROR "discards result" - defer real(1i) // ERROR "discards result" - defer unsafe.Alignof(a) // ERROR "discards result" - defer unsafe.Offsetof(s.f) // ERROR "discards result" - defer unsafe.Sizeof(a) // ERROR "discards result" + defer append(a, 0) // ERROR "not used|discards result" + defer cap(a) // ERROR "not used|discards result" + defer complex(1, 2) // ERROR "not used|discards result" + defer imag(1i) // ERROR "not used|discards result" + defer len(a) // ERROR "not used|discards result" + defer make([]int, 10) // ERROR "not used|discards result" + defer new(int) // ERROR "not used|discards result" + defer real(1i) // ERROR "not used|discards result" + defer unsafe.Alignof(a) // ERROR "not used|discards result" + defer unsafe.Offsetof(s.f) // ERROR "not used|discards result" + defer unsafe.Sizeof(a) // ERROR "not used|discards result" defer close(c) defer copy(a, a) diff --git a/test/fixedbugs/issue4517d.go b/test/fixedbugs/issue4517d.go new file mode 100644 index 000000000..f601db66f --- /dev/null +++ b/test/fixedbugs/issue4517d.go @@ -0,0 +1,9 @@ +// errorcheck + +// Copyright 2012 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. + +package p + +import init "fmt" // ERROR "cannot import package as init - init must be a func" diff --git a/test/fixedbugs/issue4545.go b/test/fixedbugs/issue4545.go index 3f2de16d2..501caadb0 100644 --- a/test/fixedbugs/issue4545.go +++ b/test/fixedbugs/issue4545.go @@ -13,7 +13,7 @@ import "fmt" func main() { var s uint - fmt.Println(1.0 + 1<<s) // ERROR "invalid operation" - x := 1.0 + 1<<s // ERROR "invalid operation" + fmt.Println(1.0 + 1<<s) // ERROR "invalid operation|non-integer type" + x := 1.0 + 1<<s // ERROR "invalid operation|non-integer type" _ = x } diff --git a/test/fixedbugs/issue4776.go b/test/fixedbugs/issue4776.go new file mode 100644 index 000000000..c38dc09b1 --- /dev/null +++ b/test/fixedbugs/issue4776.go @@ -0,0 +1,10 @@ +// errorcheck + +// Copyright 2013 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. + +// Issue 4776: missing package declaration error should be fatal. + +type MyInt int32 // ERROR "package statement must be first" + diff --git a/test/fixedbugs/issue4813.go b/test/fixedbugs/issue4813.go index 0ca9d3f72..20dc58795 100644 --- a/test/fixedbugs/issue4813.go +++ b/test/fixedbugs/issue4813.go @@ -31,22 +31,22 @@ var ( a3 = A[f2] // ERROR "truncated" a4 = A[c] a5 = A[c2] // ERROR "truncated" - a6 = A[vf] // ERROR "non-integer" - a7 = A[vc] // ERROR "non-integer" + a6 = A[vf] // ERROR "non-integer|must be integer" + a7 = A[vc] // ERROR "non-integer|must be integer" s1 = S[i] s2 = S[f] s3 = S[f2] // ERROR "truncated" s4 = S[c] s5 = S[c2] // ERROR "truncated" - s6 = S[vf] // ERROR "non-integer" - s7 = S[vc] // ERROR "non-integer" + s6 = S[vf] // ERROR "non-integer|must be integer" + s7 = S[vc] // ERROR "non-integer|must be integer" t1 = T[i] t2 = T[f] t3 = T[f2] // ERROR "truncated" t4 = T[c] t5 = T[c2] // ERROR "truncated" - t6 = T[vf] // ERROR "non-integer" - t7 = T[vc] // ERROR "non-integer" + t6 = T[vf] // ERROR "non-integer|must be integer" + t7 = T[vc] // ERROR "non-integer|must be integer" ) diff --git a/test/fixedbugs/issue4847.go b/test/fixedbugs/issue4847.go new file mode 100644 index 000000000..a99e80129 --- /dev/null +++ b/test/fixedbugs/issue4847.go @@ -0,0 +1,24 @@ +// errorcheck + +// Copyright 2013 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. + +// Issue 4847: initialization loop is not detected. + +package p + +type ( + E int + S int +) + +type matcher func(s *S) E + +func matchList(s *S) E { return matcher(matchAnyFn)(s) } + +var foo = matcher(matchList) + +var matchAny = matcher(matchList) // ERROR "initialization loop" + +func matchAnyFn(s *S) (err E) { return matchAny(s) } diff --git a/test/fixedbugs/issue5172.go b/test/fixedbugs/issue5172.go new file mode 100644 index 000000000..2dd542a5d --- /dev/null +++ b/test/fixedbugs/issue5172.go @@ -0,0 +1,19 @@ +// errorcheck + +// Copyright 2013 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. + +// issue 5172: spurious warn about type conversion on broken type inside go and defer + +package main + +type foo struct { + x bar // ERROR "undefined" +} + +func main() { + var f foo + go f.bar() + defer f.bar() +} diff --git a/test/fixedbugs/issue5358.go b/test/fixedbugs/issue5358.go new file mode 100644 index 000000000..75aa9533d --- /dev/null +++ b/test/fixedbugs/issue5358.go @@ -0,0 +1,17 @@ +// errorcheck + +// Copyright 2013 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. + +// issue 5358: incorrect error message when using f(g()) form on ... args. + +package main + +func f(x int, y ...int) {} + +func g() (int, []int) + +func main() { + f(g()) // ERROR "as type int in" +} diff --git a/test/fixedbugs/issue5493.go b/test/fixedbugs/issue5493.go index 827281bdc..affc07b58 100644 --- a/test/fixedbugs/issue5493.go +++ b/test/fixedbugs/issue5493.go @@ -51,7 +51,7 @@ func main() { runtime.GC() } if count != 0 { - println(count, "out of", N, "finalizer are called") + println(count, "out of", N, "finalizer are not called") panic("not all finalizers are called") } } diff --git a/test/fixedbugs/issue5581.go b/test/fixedbugs/issue5581.go new file mode 100644 index 000000000..8c2d59729 --- /dev/null +++ b/test/fixedbugs/issue5581.go @@ -0,0 +1,34 @@ +// errorcheck + +// Used to emit a spurious "invalid recursive type" error. +// See golang.org/issue/5581. + +// Copyright 2013 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. + +package main + +import "fmt" + +func NewBar() *Bar { return nil } + +func (x *Foo) Method() (int, error) { + for y := range x.m { + _ = y.A + } + return 0, nil +} + +type Foo struct { + m map[*Bar]int +} + +type Bar struct { + A *Foo + B chan Blah // ERROR "undefined: Blah" +} + +func main() { + fmt.Println("Hello, playground") +} diff --git a/test/fixedbugs/issue5609.go b/test/fixedbugs/issue5609.go new file mode 100644 index 000000000..ea770b486 --- /dev/null +++ b/test/fixedbugs/issue5609.go @@ -0,0 +1,13 @@ +// errorcheck + +// Copyright 2013 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. + +// issue 5609: overflow when calculating array size + +package pkg + +const Large uint64 = 18446744073709551615 + +var foo [Large]uint64 // ERROR "array bound is too large|array bound overflows" diff --git a/test/fixedbugs/issue5698.go b/test/fixedbugs/issue5698.go new file mode 100644 index 000000000..035bbd35d --- /dev/null +++ b/test/fixedbugs/issue5698.go @@ -0,0 +1,18 @@ +// errorcheck + +// Copyright 2013 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. + +// Issue 5698: can define a key type with slices. + +package main + +type Key struct { + a int16 // the compiler was confused by the padding. + b []int +} + +type Val struct{} + +type Map map[Key]Val // ERROR "invalid map key type" diff --git a/test/fixedbugs/issue5704.go b/test/fixedbugs/issue5704.go new file mode 100644 index 000000000..1dfa07214 --- /dev/null +++ b/test/fixedbugs/issue5704.go @@ -0,0 +1,46 @@ +// run + +// Copyright 2012 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. + +// Issue 5704: Conversions of empty strings to byte +// or rune slices return empty but non-nil slices. + +package main + +type ( + mystring string + mybytes []byte + myrunes []rune +) + +func checkBytes(s []byte, arg string) { + if len(s) != 0 { + panic("len(" + arg + ") != 0") + } + if s == nil { + panic(arg + " == nil") + } +} + +func checkRunes(s []rune, arg string) { + if len(s) != 0 { + panic("len(" + arg + ") != 0") + } + if s == nil { + panic(arg + " == nil") + } +} + +func main() { + checkBytes([]byte(""), `[]byte("")`) + checkBytes([]byte(mystring("")), `[]byte(mystring(""))`) + checkBytes(mybytes(""), `mybytes("")`) + checkBytes(mybytes(mystring("")), `mybytes(mystring(""))`) + + checkRunes([]rune(""), `[]rune("")`) + checkRunes([]rune(mystring("")), `[]rune(mystring(""))`) + checkRunes(myrunes(""), `myrunes("")`) + checkRunes(myrunes(mystring("")), `myrunes(mystring(""))`) +} diff --git a/test/fixedbugs/issue5856.go b/test/fixedbugs/issue5856.go new file mode 100644 index 000000000..35cadf8c9 --- /dev/null +++ b/test/fixedbugs/issue5856.go @@ -0,0 +1,38 @@ +// run + +// Copyright 2013 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. + +package main + +import ( + "fmt" + "os" + "runtime" + "strings" +) + +func main() { + f() + panic("deferred function not run") +} + +var x = 1 + +func f() { + if x == 0 { + return + } + defer g() + panic("panic") +} + +func g() { + _, file, line, _ := runtime.Caller(2) + if !strings.HasSuffix(file, "issue5856.go") || line != 28 { + fmt.Printf("BUG: defer called from %s:%d, want issue5856.go:28\n", file, line) + os.Exit(1) + } + os.Exit(0) +} diff --git a/test/fixedbugs/issue5910.dir/a.go b/test/fixedbugs/issue5910.dir/a.go new file mode 100644 index 000000000..b236c15c7 --- /dev/null +++ b/test/fixedbugs/issue5910.dir/a.go @@ -0,0 +1,22 @@ +// Copyright 2013 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. + +package a + +type Package struct { + name string +} + +type Future struct { + result chan struct { + *Package + error + } +} + +func (t *Future) Result() (*Package, error) { + result := <-t.result + t.result <- result + return result.Package, result.error +} diff --git a/test/fixedbugs/issue5910.dir/main.go b/test/fixedbugs/issue5910.dir/main.go new file mode 100644 index 000000000..c5d42ea09 --- /dev/null +++ b/test/fixedbugs/issue5910.dir/main.go @@ -0,0 +1,12 @@ +// Copyright 2013 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. + +package main + +import "a" + +func main() { + f := new(a.Future) + f.Result() +} diff --git a/test/fixedbugs/issue5910.go b/test/fixedbugs/issue5910.go new file mode 100644 index 000000000..54e74bac8 --- /dev/null +++ b/test/fixedbugs/issue5910.go @@ -0,0 +1,10 @@ +// compiledir + +// Copyright 2013 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. + +// Issue 5910: parsing of unnamed struct types +// in inlined bodies was broken. + +package ignored diff --git a/test/fixedbugs/issue5957.dir/a.go b/test/fixedbugs/issue5957.dir/a.go new file mode 100644 index 000000000..7411d5fcd --- /dev/null +++ b/test/fixedbugs/issue5957.dir/a.go @@ -0,0 +1,3 @@ +package surprise + +var X int diff --git a/test/fixedbugs/issue5957.dir/b.go b/test/fixedbugs/issue5957.dir/b.go new file mode 100644 index 000000000..9bc561b9c --- /dev/null +++ b/test/fixedbugs/issue5957.dir/b.go @@ -0,0 +1,2 @@ +package surprise2 + diff --git a/test/fixedbugs/issue5957.dir/c.go b/test/fixedbugs/issue5957.dir/c.go new file mode 100644 index 000000000..42c88177b --- /dev/null +++ b/test/fixedbugs/issue5957.dir/c.go @@ -0,0 +1,12 @@ +package p + +import ( + "./a" // ERROR "imported and not used: \x22a\x22 as surprise" + "./b" // ERROR "imported and not used: \x22b\x22 as surprise2" + b "./b" // ERROR "imported and not used: \x22b\x22$" + foo "math" // ERROR "imported and not used: \x22math\x22 as foo" + "fmt" // actually used + "strings" // ERROR "imported and not used: \x22strings\x22" +) + +var _ = fmt.Printf diff --git a/test/fixedbugs/issue5957.go b/test/fixedbugs/issue5957.go new file mode 100644 index 000000000..891d8e6d2 --- /dev/null +++ b/test/fixedbugs/issue5957.go @@ -0,0 +1,7 @@ +// errorcheckdir + +// Copyright 2013 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. + +package ignored diff --git a/test/fixedbugs/issue5963.go b/test/fixedbugs/issue5963.go new file mode 100644 index 000000000..190e8f456 --- /dev/null +++ b/test/fixedbugs/issue5963.go @@ -0,0 +1,50 @@ +// run + +// Copyright 2013 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. + +// Used to die in runtime due to init goroutine exiting while +// locked to main thread. + +package main + +import ( + "os" + "runtime" +) + +func init() { + c := make(chan int, 1) + defer func() { + c <- 0 + }() + go func() { + os.Exit(<-c) + }() + runtime.Goexit() +} + +func main() { +} + +/* Before fix: + +invalid m->locked = 2 +fatal error: internal lockOSThread error + +goroutine 2 [runnable]: +runtime.MHeap_Scavenger() + /Users/rsc/g/go/src/pkg/runtime/mheap.c:438 +runtime.goexit() + /Users/rsc/g/go/src/pkg/runtime/proc.c:1313 +created by runtime.main + /Users/rsc/g/go/src/pkg/runtime/proc.c:165 + +goroutine 3 [runnable]: +main.func·002() + /Users/rsc/g/go/test/fixedbugs/issue5963.go:22 +created by main.init·1 + /Users/rsc/g/go/test/fixedbugs/issue5963.go:24 +0xb9 +exit status 2 +*/ diff --git a/test/fixedbugs/issue6004.go b/test/fixedbugs/issue6004.go new file mode 100644 index 000000000..45aaffd2c --- /dev/null +++ b/test/fixedbugs/issue6004.go @@ -0,0 +1,15 @@ +// errorcheck + +// Copyright 2013 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. + +package main + +func main() { + _ = nil // ERROR "use of untyped nil" + _, _ = nil, 1 // ERROR "use of untyped nil" + _, _ = 1, nil // ERROR "use of untyped nil" + _ = append(nil, 1, 2, 3) // ERROR "untyped nil" +} + diff --git a/test/fixedbugs/issue6036.go b/test/fixedbugs/issue6036.go new file mode 100644 index 000000000..5f787c569 --- /dev/null +++ b/test/fixedbugs/issue6036.go @@ -0,0 +1,44 @@ +// +build amd64 +// compile + +// Copyright 2013 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. + +// Issue 6036: 6g's backend generates OINDREG with +// offsets larger than 32-bit. + +package main + +type T struct { + Large [1 << 31]byte + A int + B int +} + +func F(t *T) { + t.B = t.A +} + +type T2 [1<<31 + 2]byte + +func F2(t *T2) { + t[1<<31+1] = 42 +} + +type T3 [1<<15 + 1][1<<15 + 1]int + +func F3(t *T3) { + t[1<<15][1<<15] = 42 +} + +type S struct { + A int32 + B int32 +} + +type T4 [1<<29 + 1]S + +func F4(t *T4) { + t[1<<29].B = 42 +} diff --git a/test/fixedbugs/issue6055.go b/test/fixedbugs/issue6055.go new file mode 100644 index 000000000..698f62ac9 --- /dev/null +++ b/test/fixedbugs/issue6055.go @@ -0,0 +1,35 @@ +// run + +// Copyright 2013 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. + +package main + +import "runtime" + +type Closer interface { + Close() +} + +func nilInterfaceDeferCall() { + defer func() { + // make sure a traceback happens with jmpdefer on the stack + runtime.GC() + }() + var x Closer + defer x.Close() +} + +func shouldPanic(f func()) { + defer func() { + if recover() == nil { + panic("did not panic") + } + }() + f() +} + +func main() { + shouldPanic(nilInterfaceDeferCall) +} diff --git a/test/fixedbugs/issue6131.go b/test/fixedbugs/issue6131.go new file mode 100644 index 000000000..817e4a877 --- /dev/null +++ b/test/fixedbugs/issue6131.go @@ -0,0 +1,20 @@ +// compile + +// Copyright 2013 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. + +// Issue 6131: missing typecheck after reducing +// n%1 == 0 to a constant value. + +package main + +func isGood(n int) bool { + return n%1 == 0 +} + +func main() { + if !isGood(256) { + panic("!isGood") + } +} diff --git a/test/fixedbugs/issue6140.go b/test/fixedbugs/issue6140.go new file mode 100644 index 000000000..d494933b2 --- /dev/null +++ b/test/fixedbugs/issue6140.go @@ -0,0 +1,31 @@ +// compile + +// Copyright 2013 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. + +// Issue 6140: compiler incorrectly rejects method values +// whose receiver has an unnamed interface type. + +package p + +type T *interface { + m() int +} + +var x T + +var _ = (*x).m + +var y interface { + m() int +} + +var _ = y.m + +type I interface { + String() string +} + +var z *struct{ I } +var _ = z.String diff --git a/test/fixedbugs/issue6247.go b/test/fixedbugs/issue6247.go new file mode 100644 index 000000000..eea8f9c87 --- /dev/null +++ b/test/fixedbugs/issue6247.go @@ -0,0 +1,17 @@ +// compile + +// Copyright 2013 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. + +// Issue 6247: 5g used to be confused by the numbering +// of floating-point registers. + +package main + +var p map[string]interface{} +var v interface{} + +func F() { + p["hello"] = v.(complex128) * v.(complex128) +} diff --git a/test/fixedbugs/issue6269.go b/test/fixedbugs/issue6269.go new file mode 100644 index 000000000..af5feb728 --- /dev/null +++ b/test/fixedbugs/issue6269.go @@ -0,0 +1,39 @@ +// run + +// Copyright 2013 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. + +// issue 6269: name collision on method names for function local types. + +package main + +type foo struct{} + +func (foo) Error() string { + return "ok" +} + +type bar struct{} + +func (bar) Error() string { + return "fail" +} + +func unused() { + type collision struct { + bar + } + _ = collision{} +} + +func main() { + type collision struct { + foo + } + s := error(collision{}) + if str := s.Error(); str != "ok" { + println("s.Error() ==", str) + panic(`s.Error() != "ok"`) + } +} diff --git a/test/fixedbugs/issue6298.go b/test/fixedbugs/issue6298.go new file mode 100644 index 000000000..6303dbe5b --- /dev/null +++ b/test/fixedbugs/issue6298.go @@ -0,0 +1,15 @@ +// compile + +// golang.org/issue/6298. +// Used to cause "internal error: typename ideal bool" + +// Copyright 2013 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. + +package main + +func main() { + var x interface{} = "abc"[0] == 'a' + _ = x +} diff --git a/test/fixedbugs/issue6399.go b/test/fixedbugs/issue6399.go new file mode 100644 index 000000000..b3d1c855b --- /dev/null +++ b/test/fixedbugs/issue6399.go @@ -0,0 +1,27 @@ +// compile + +package main + +type Foo interface { + Print() +} + +type Bar struct{} + +func (b Bar) Print() {} + +func main() { + b := make([]Bar, 20) + f := make([]Foo, 20) + for i := range f { + f[i] = b[i] + } + T(f) + _ = make([]struct{}, 1) +} + +func T(f []Foo) { + for i := range f { + f[i].Print() + } +} diff --git a/test/fixedbugs/issue6513.dir/a.go b/test/fixedbugs/issue6513.dir/a.go new file mode 100644 index 000000000..da90ca377 --- /dev/null +++ b/test/fixedbugs/issue6513.dir/a.go @@ -0,0 +1,7 @@ +// Copyright 2013 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. + +package a + +type T struct{ int } diff --git a/test/fixedbugs/issue6513.dir/b.go b/test/fixedbugs/issue6513.dir/b.go new file mode 100644 index 000000000..3b35b2d32 --- /dev/null +++ b/test/fixedbugs/issue6513.dir/b.go @@ -0,0 +1,9 @@ +// Copyright 2013 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. + +package b + +import "./a" + +type U struct{ a.T } diff --git a/test/fixedbugs/issue6513.dir/main.go b/test/fixedbugs/issue6513.dir/main.go new file mode 100644 index 000000000..f09b72748 --- /dev/null +++ b/test/fixedbugs/issue6513.dir/main.go @@ -0,0 +1,16 @@ +// Copyright 2013 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. + +package main + +import ( + "./a" + "./b" +) + +func main() { + var t a.T + var u b.U + _, _ = t, u +} diff --git a/test/fixedbugs/issue6513.go b/test/fixedbugs/issue6513.go new file mode 100644 index 000000000..b32e0c561 --- /dev/null +++ b/test/fixedbugs/issue6513.go @@ -0,0 +1,10 @@ +// compiledir + +// Copyright 2013 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. + +// Issue 6513: embedded builtins may get incorrect qualified +// field name during import. + +package ignored diff --git a/test/import1.go b/test/import1.go index 56b29d58c..d2bb55cbf 100644 --- a/test/import1.go +++ b/test/import1.go @@ -14,5 +14,6 @@ import bufio "os" // ERROR "redeclared|redefinition|incompatible" "imported and import ( "fmt" // GCCGO_ERROR "previous|not used" - fmt "math" // ERROR "redeclared|redefinition|incompatible" "imported and not used" + fmt "math" // ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt" + . "math" // ERROR "imported and not used: \x22math\x22$" ) diff --git a/test/index.go b/test/index.go index f9360c102..a8c471bb3 100644 --- a/test/index.go +++ b/test/index.go @@ -164,7 +164,7 @@ func testExpr(b *bufio.Writer, expr string) { if pass == 0 { fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr) } else { - fmt.Fprintf(b, "\tuse(%s) // ERROR \"index|overflow|truncated\"\n", expr) + fmt.Fprintf(b, "\tuse(%s) // ERROR \"index|overflow|truncated|must be integer\"\n", expr) } } diff --git a/test/interface/explicit.go b/test/interface/explicit.go index eb81156e0..36fa1a422 100644 --- a/test/interface/explicit.go +++ b/test/interface/explicit.go @@ -80,3 +80,22 @@ var m2 M = jj // ERROR "incompatible|wrong type for M method" var m3 = M(ii) // ERROR "invalid|missing" var m4 = M(jj) // ERROR "invalid|wrong type for M method" + + +type B1 interface { + _() +} + +type B2 interface { + M() + _() +} + +type T2 struct{} + +func (t *T2) M() {} +func (t *T2) _() {} + +// Check that nothing satisfies an interface with blank methods. +var b1 B1 = &T2{} // ERROR "incompatible|missing _ method" +var b2 B2 = &T2{} // ERROR "incompatible|missing _ method" diff --git a/test/interface/fail.go b/test/interface/fail.go index 72b854dc0..81eb6cb3c 100644 --- a/test/interface/fail.go +++ b/test/interface/fail.go @@ -14,18 +14,33 @@ type I interface { func main() { shouldPanic(p1) + shouldPanic(p2) } func p1() { var s *S var i I - var e interface {} + var e interface{} e = s i = e.(I) _ = i } -type S struct { +type S struct{} + +func (s *S) _() {} + +type B interface { + _() +} + +func p2() { + var s *S + var b B + var e interface{} + e = s + b = e.(B) + _ = b } func shouldPanic(f func()) { diff --git a/test/mapnan.go b/test/mapnan.go index 60b35fbea..f081cab01 100644 --- a/test/mapnan.go +++ b/test/mapnan.go @@ -13,17 +13,13 @@ import ( "fmt" "math" "time" - "syscall" ) func main() { // Test that NaNs in maps don't go quadratic. t := func(n int) time.Duration { - var u0 syscall.Rusage - if err := syscall.Getrusage(0, &u0); err != nil { - panic(err) - } + t1 := time.Now() m := map[float64]int{} nan := math.NaN() for i := 0; i < n; i++ { @@ -32,11 +28,7 @@ func main() { if len(m) != n { panic("wrong size map after nan insertion") } - var u1 syscall.Rusage - if err := syscall.Getrusage(0, &u1); err != nil { - panic(err) - } - return time.Duration(u1.Utime.Nano() - u0.Utime.Nano()) + return time.Since(t1) } // Depending on the machine and OS, this test might be too fast diff --git a/test/method2.go b/test/method2.go index b63da10dc..aaa850e71 100644 --- a/test/method2.go +++ b/test/method2.go @@ -21,7 +21,7 @@ func (p *P1) val() int { return 1 } // ERROR "receiver.* pointer|invalid pointer type I interface{} type I1 interface{} -func (p I) val() int { return 1 } // ERROR "receiver.*interface|invalid pointer or interface receiver" +func (p I) val() int { return 1 } // ERROR "receiver.*interface|invalid pointer or interface receiver" func (p *I1) val() int { return 1 } // ERROR "receiver.*interface|invalid pointer or interface receiver" type Val interface { @@ -33,4 +33,5 @@ var _ = (*Val).val // ERROR "method" var v Val var pv = &v -var _ = pv.val() // ERROR "method" +var _ = pv.val() // ERROR "method" +var _ = pv.val // ERROR "method" diff --git a/test/nilcheck.go b/test/nilcheck.go new file mode 100644 index 000000000..fe05d05c9 --- /dev/null +++ b/test/nilcheck.go @@ -0,0 +1,184 @@ +// errorcheck -0 -N -d=nil + +// Copyright 2013 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. + +// Test that nil checks are inserted. +// Optimization is disabled, so redundant checks are not removed. + +package p + +type Struct struct { + X int + Y float64 +} + +type BigStruct struct { + X int + Y float64 + A [1<<20]int + Z string +} + +type Empty struct { +} + +type Empty1 struct { + Empty +} + +var ( + intp *int + arrayp *[10]int + array0p *[0]int + bigarrayp *[1<<26]int + structp *Struct + bigstructp *BigStruct + emptyp *Empty + empty1p *Empty1 +) + +func f1() { + _ = *intp // ERROR "nil check" + _ = *arrayp // ERROR "nil check" + _ = *array0p // ERROR "nil check" + _ = *array0p // ERROR "nil check" + _ = *intp // ERROR "nil check" + _ = *arrayp // ERROR "nil check" + _ = *structp // ERROR "nil check" + _ = *emptyp // ERROR "nil check" + _ = *arrayp // ERROR "nil check" +} + +func f2() { + var ( + intp *int + arrayp *[10]int + array0p *[0]int + bigarrayp *[1<<20]int + structp *Struct + bigstructp *BigStruct + emptyp *Empty + empty1p *Empty1 + ) + + _ = *intp // ERROR "nil check" + _ = *arrayp // ERROR "nil check" + _ = *array0p // ERROR "nil check" + _ = *array0p // ERROR "nil check" + _ = *intp // ERROR "nil check" + _ = *arrayp // ERROR "nil check" + _ = *structp // ERROR "nil check" + _ = *emptyp // ERROR "nil check" + _ = *arrayp // ERROR "nil check" + _ = *bigarrayp // ERROR "nil check" + _ = *bigstructp // ERROR "nil check" + _ = *empty1p // ERROR "nil check" +} + +func fx10k() *[10000]int +var b bool + + +func f3(x *[10000]int) { + // Using a huge type and huge offsets so the compiler + // does not expect the memory hardware to fault. + _ = x[9999] // ERROR "nil check" + + for { + if x[9999] != 0 { // ERROR "nil check" + break + } + } + + x = fx10k() + _ = x[9999] // ERROR "nil check" + if b { + _ = x[9999] // ERROR "nil check" + } else { + _ = x[9999] // ERROR "nil check" + } + _ = x[9999] // ERROR "nil check" + + x = fx10k() + if b { + _ = x[9999] // ERROR "nil check" + } else { + _ = x[9999] // ERROR "nil check" + } + _ = x[9999] // ERROR "nil check" + + fx10k() + // This one is a bit redundant, if we figured out that + // x wasn't going to change across the function call. + // But it's a little complex to do and in practice doesn't + // matter enough. + _ = x[9999] // ERROR "nil check" +} + +func f3a() { + x := fx10k() + y := fx10k() + z := fx10k() + _ = &x[9] // ERROR "nil check" + y = z + _ = &x[9] // ERROR "nil check" + x = y + _ = &x[9] // ERROR "nil check" +} + +func f3b() { + x := fx10k() + y := fx10k() + _ = &x[9] // ERROR "nil check" + y = x + _ = &x[9] // ERROR "nil check" + x = y + _ = &x[9] // ERROR "nil check" +} + +func fx10() *[10]int + +func f4(x *[10]int) { + // Most of these have no checks because a real memory reference follows, + // and the offset is small enough that if x is nil, the address will still be + // in the first unmapped page of memory. + + _ = x[9] // ERROR "nil check" + + for { + if x[9] != 0 { // ERROR "nil check" + break + } + } + + x = fx10() + _ = x[9] // ERROR "nil check" + if b { + _ = x[9] // ERROR "nil check" + } else { + _ = x[9] // ERROR "nil check" + } + _ = x[9] // ERROR "nil check" + + x = fx10() + if b { + _ = x[9] // ERROR "nil check" + } else { + _ = &x[9] // ERROR "nil check" + } + _ = x[9] // ERROR "nil check" + + fx10() + _ = x[9] // ERROR "nil check" + + x = fx10() + y := fx10() + _ = &x[9] // ERROR "nil check" + y = x + _ = &x[9] // ERROR "nil check" + x = y + _ = &x[9] // ERROR "nil check" +} + diff --git a/test/nilptr.go b/test/nilptr.go index 793e99673..9631d1618 100644 --- a/test/nilptr.go +++ b/test/nilptr.go @@ -40,6 +40,10 @@ func main() { shouldPanic(p10) shouldPanic(p11) shouldPanic(p12) + shouldPanic(p13) + shouldPanic(p14) + shouldPanic(p15) + shouldPanic(p16) } func shouldPanic(f func()) { @@ -152,3 +156,27 @@ func p12() { var p *T = nil println(*(&((*p).i))) } + +// Tests suggested in golang.org/issue/6080. + +func p13() { + var x *[10]int + y := x[:] + _ = y +} + +func p14() { + println((*[1]int)(nil)[:]) +} + +func p15() { + for i := range (*[1]int)(nil)[:] { + _ = i + } +} + +func p16() { + for i, v := range (*[1]int)(nil)[:] { + _ = i + v + } +} diff --git a/test/nilptr2.go b/test/nilptr2.go new file mode 100644 index 000000000..57a5f8068 --- /dev/null +++ b/test/nilptr2.go @@ -0,0 +1,128 @@ +// run + +// Copyright 2013 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. + +package main + +func main() { + ok := true + for _, tt := range tests { + func() { + defer func() { + if err := recover(); err == nil { + println(tt.name, "did not panic") + ok = false + } + }() + tt.fn() + }() + } + if !ok { + println("BUG") + } +} + +var intp *int +var slicep *[]byte +var a10p *[10]int +var a10Mp *[1<<20]int +var structp *Struct +var bigstructp *BigStruct +var i int +var m *M +var m1 *M1 +var m2 *M2 + +func use(interface{}) { +} + +var tests = []struct{ + name string + fn func() +}{ + // Edit .+1,/^}/s/^[^ ].+/ {"&", func() { println(&) }},\n {"\&&", func() { println(\&&) }},/g + {"*intp", func() { println(*intp) }}, + {"&*intp", func() { println(&*intp) }}, + {"*slicep", func() { println(*slicep) }}, + {"&*slicep", func() { println(&*slicep) }}, + {"(*slicep)[0]", func() { println((*slicep)[0]) }}, + {"&(*slicep)[0]", func() { println(&(*slicep)[0]) }}, + {"(*slicep)[i]", func() { println((*slicep)[i]) }}, + {"&(*slicep)[i]", func() { println(&(*slicep)[i]) }}, + {"*a10p", func() { use(*a10p) }}, + {"&*a10p", func() { println(&*a10p) }}, + {"a10p[0]", func() { println(a10p[0]) }}, + {"&a10p[0]", func() { println(&a10p[0]) }}, + {"a10p[i]", func() { println(a10p[i]) }}, + {"&a10p[i]", func() { println(&a10p[i]) }}, + {"*structp", func() { use(*structp) }}, + {"&*structp", func() { println(&*structp) }}, + {"structp.i", func() { println(structp.i) }}, + {"&structp.i", func() { println(&structp.i) }}, + {"structp.j", func() { println(structp.j) }}, + {"&structp.j", func() { println(&structp.j) }}, + {"structp.k", func() { println(structp.k) }}, + {"&structp.k", func() { println(&structp.k) }}, + {"structp.x[0]", func() { println(structp.x[0]) }}, + {"&structp.x[0]", func() { println(&structp.x[0]) }}, + {"structp.x[i]", func() { println(structp.x[i]) }}, + {"&structp.x[i]", func() { println(&structp.x[i]) }}, + {"structp.x[9]", func() { println(structp.x[9]) }}, + {"&structp.x[9]", func() { println(&structp.x[9]) }}, + {"structp.l", func() { println(structp.l) }}, + {"&structp.l", func() { println(&structp.l) }}, + {"*bigstructp", func() { use(*bigstructp) }}, + {"&*bigstructp", func() { println(&*bigstructp) }}, + {"bigstructp.i", func() { println(bigstructp.i) }}, + {"&bigstructp.i", func() { println(&bigstructp.i) }}, + {"bigstructp.j", func() { println(bigstructp.j) }}, + {"&bigstructp.j", func() { println(&bigstructp.j) }}, + {"bigstructp.k", func() { println(bigstructp.k) }}, + {"&bigstructp.k", func() { println(&bigstructp.k) }}, + {"bigstructp.x[0]", func() { println(bigstructp.x[0]) }}, + {"&bigstructp.x[0]", func() { println(&bigstructp.x[0]) }}, + {"bigstructp.x[i]", func() { println(bigstructp.x[i]) }}, + {"&bigstructp.x[i]", func() { println(&bigstructp.x[i]) }}, + {"bigstructp.x[9]", func() { println(bigstructp.x[9]) }}, + {"&bigstructp.x[9]", func() { println(&bigstructp.x[9]) }}, + {"bigstructp.x[100<<20]", func() { println(bigstructp.x[100<<20]) }}, + {"&bigstructp.x[100<<20]", func() { println(&bigstructp.x[100<<20]) }}, + {"bigstructp.l", func() { println(bigstructp.l) }}, + {"&bigstructp.l", func() { println(&bigstructp.l) }}, + {"m1.F()", func() { println(m1.F()) }}, + {"m1.M.F()", func() { println(m1.M.F()) }}, + {"m2.F()", func() { println(m2.F()) }}, + {"m2.M.F()", func() { println(m2.M.F()) }}, +} + +type Struct struct { + i int + j float64 + k string + x [10]int + l []byte +} + +type BigStruct struct { + i int + j float64 + k string + x [128<<20]byte + l []byte +} + +type M struct { +} + +func (m *M) F() int {return 0} + +type M1 struct { + M +} + +type M2 struct { + x int + M +} diff --git a/test/nilptr3.go b/test/nilptr3.go new file mode 100644 index 000000000..08597a02d --- /dev/null +++ b/test/nilptr3.go @@ -0,0 +1,191 @@ +// errorcheck -0 -d=nil + +// Copyright 2013 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. + +// Test that nil checks are removed. +// Optimization is enabled. + +package p + +type Struct struct { + X int + Y float64 +} + +type BigStruct struct { + X int + Y float64 + A [1<<20]int + Z string +} + +type Empty struct { +} + +type Empty1 struct { + Empty +} + +var ( + intp *int + arrayp *[10]int + array0p *[0]int + bigarrayp *[1<<26]int + structp *Struct + bigstructp *BigStruct + emptyp *Empty + empty1p *Empty1 +) + +func f1() { + _ = *intp // ERROR "generated nil check" + + // This one should be removed but the block copy needs + // to be turned into its own pseudo-op in order to see + // the indirect. + _ = *arrayp // ERROR "generated nil check" + + // 0-byte indirect doesn't suffice + _ = *array0p // ERROR "generated nil check" + _ = *array0p // ERROR "removed repeated nil check" 386 + + _ = *intp // ERROR "removed repeated nil check" + _ = *arrayp // ERROR "removed repeated nil check" + _ = *structp // ERROR "generated nil check" + _ = *emptyp // ERROR "generated nil check" + _ = *arrayp // ERROR "removed repeated nil check" +} + +func f2() { + var ( + intp *int + arrayp *[10]int + array0p *[0]int + bigarrayp *[1<<20]int + structp *Struct + bigstructp *BigStruct + emptyp *Empty + empty1p *Empty1 + ) + + _ = *intp // ERROR "generated nil check" + _ = *arrayp // ERROR "generated nil check" + _ = *array0p // ERROR "generated nil check" + _ = *array0p // ERROR "removed repeated nil check" + _ = *intp // ERROR "removed repeated nil check" + _ = *arrayp // ERROR "removed repeated nil check" + _ = *structp // ERROR "generated nil check" + _ = *emptyp // ERROR "generated nil check" + _ = *arrayp // ERROR "removed repeated nil check" + _ = *bigarrayp // ERROR "generated nil check" ARM removed nil check before indirect!! + _ = *bigstructp // ERROR "generated nil check" + _ = *empty1p // ERROR "generated nil check" +} + +func fx10k() *[10000]int +var b bool + + +func f3(x *[10000]int) { + // Using a huge type and huge offsets so the compiler + // does not expect the memory hardware to fault. + _ = x[9999] // ERROR "generated nil check" + + for { + if x[9999] != 0 { // ERROR "generated nil check" + break + } + } + + x = fx10k() + _ = x[9999] // ERROR "generated nil check" + if b { + _ = x[9999] // ERROR "removed repeated nil check" + } else { + _ = x[9999] // ERROR "removed repeated nil check" + } + _ = x[9999] // ERROR "generated nil check" + + x = fx10k() + if b { + _ = x[9999] // ERROR "generated nil check" + } else { + _ = x[9999] // ERROR "generated nil check" + } + _ = x[9999] // ERROR "generated nil check" + + fx10k() + // This one is a bit redundant, if we figured out that + // x wasn't going to change across the function call. + // But it's a little complex to do and in practice doesn't + // matter enough. + _ = x[9999] // ERROR "generated nil check" +} + +func f3a() { + x := fx10k() + y := fx10k() + z := fx10k() + _ = &x[9] // ERROR "generated nil check" + y = z + _ = &x[9] // ERROR "removed repeated nil check" + x = y + _ = &x[9] // ERROR "generated nil check" +} + +func f3b() { + x := fx10k() + y := fx10k() + _ = &x[9] // ERROR "generated nil check" + y = x + _ = &x[9] // ERROR "removed repeated nil check" + x = y + _ = &x[9] // ERROR "removed repeated nil check" +} + +func fx10() *[10]int + +func f4(x *[10]int) { + // Most of these have no checks because a real memory reference follows, + // and the offset is small enough that if x is nil, the address will still be + // in the first unmapped page of memory. + + _ = x[9] // ERROR "removed nil check before indirect" + + for { + if x[9] != 0 { // ERROR "removed nil check before indirect" + break + } + } + + x = fx10() + _ = x[9] // ERROR "removed nil check before indirect" + if b { + _ = x[9] // ERROR "removed nil check before indirect" + } else { + _ = x[9] // ERROR "removed nil check before indirect" + } + _ = x[9] // ERROR "removed nil check before indirect" + + x = fx10() + if b { + _ = x[9] // ERROR "removed nil check before indirect" + } else { + _ = &x[9] // ERROR "generated nil check" + } + _ = x[9] // ERROR "removed nil check before indirect" + + fx10() + _ = x[9] // ERROR "removed nil check before indirect" + + x = fx10() + y := fx10() + _ = &x[9] // ERROR "generated nil check" + y = x + _ = &x[9] // ERROR "removed repeated nil check" + x = y + _ = &x[9] // ERROR "removed repeated nil check" +} + diff --git a/test/recover.go b/test/recover.go index 7c27d7c4d..071be6667 100644 --- a/test/recover.go +++ b/test/recover.go @@ -10,31 +10,72 @@ package main import ( "os" + "reflect" "runtime" ) func main() { + // go.tools/ssa/interp still has: + // - some lesser bugs in recover() + // - incomplete support for reflection + interp := os.Getenv("GOSSAINTERP") != "" + test1() test1WithClosures() test2() test3() - // exp/ssa/interp still has some bugs in recover(). - if os.Getenv("GOSSAINTERP") == "" { + if !interp { test4() - test5() } + test5() test6() test6WithClosures() test7() + test8() + test9() + if !interp { + test9reflect1() + test9reflect2() + } + test10() + if !interp { + test10reflect1() + test10reflect2() + } + test11() + if !interp { + test11reflect1() + test11reflect2() + } + test12() + if !interp { + test12reflect1() + test12reflect2() + } + test13() + if !interp { + test13reflect1() + test13reflect2() + } + test14() + if !interp { + test14reflect1() + test14reflect2() + test15() + } } func die() { runtime.Breakpoint() // can't depend on panic } -func mustRecover(x interface{}) { - mustNotRecover() // because it's not a defer call - v := recover() +func mustRecoverBody(v1, v2, v3, x interface{}) { + v := v1 + if v != nil { + println("spurious recover", v) + die() + } + v = v2 if v == nil { println("missing recover") die() // panic is useless here @@ -45,13 +86,21 @@ func mustRecover(x interface{}) { } // the value should be gone now regardless - v = recover() + v = v3 if v != nil { println("recover didn't recover") die() } } +func doubleRecover() interface{} { + return recover() +} + +func mustRecover(x interface{}) { + mustRecoverBody(doubleRecover(), recover(), recover(), x) +} + func mustNotRecover() { v := recover() if v != nil { @@ -277,3 +326,180 @@ func test8() { die() } } + +type I interface { + M() +} + +// pointer receiver, so no wrapper in i.M() +type T1 struct{} + +func (*T1) M() { + mustRecoverBody(doubleRecover(), recover(), recover(), 9) +} + +func test9() { + var i I = &T1{} + defer i.M() + panic(9) +} + +func test9reflect1() { + f := reflect.ValueOf(&T1{}).Method(0).Interface().(func()) + defer f() + panic(9) +} + +func test9reflect2() { + f := reflect.TypeOf(&T1{}).Method(0).Func.Interface().(func(*T1)) + defer f(&T1{}) + panic(9) +} + +// word-sized value receiver, so no wrapper in i.M() +type T2 uintptr + +func (T2) M() { + mustRecoverBody(doubleRecover(), recover(), recover(), 10) +} + +func test10() { + var i I = T2(0) + defer i.M() + panic(10) +} + +func test10reflect1() { + f := reflect.ValueOf(T2(0)).Method(0).Interface().(func()) + defer f() + panic(10) +} + +func test10reflect2() { + f := reflect.TypeOf(T2(0)).Method(0).Func.Interface().(func(T2)) + defer f(T2(0)) + panic(10) +} + +// tiny receiver, so basic wrapper in i.M() +type T3 struct{} + +func (T3) M() { + mustRecoverBody(doubleRecover(), recover(), recover(), 11) +} + +func test11() { + var i I = T3{} + defer i.M() + panic(11) +} + +func test11reflect1() { + f := reflect.ValueOf(T3{}).Method(0).Interface().(func()) + defer f() + panic(11) +} + +func test11reflect2() { + f := reflect.TypeOf(T3{}).Method(0).Func.Interface().(func(T3)) + defer f(T3{}) + panic(11) +} + +// large receiver, so basic wrapper in i.M() +type T4 [2]string + +func (T4) M() { + mustRecoverBody(doubleRecover(), recover(), recover(), 12) +} + +func test12() { + var i I = T4{} + defer i.M() + panic(12) +} + +func test12reflect1() { + f := reflect.ValueOf(T4{}).Method(0).Interface().(func()) + defer f() + panic(12) +} + +func test12reflect2() { + f := reflect.TypeOf(T4{}).Method(0).Func.Interface().(func(T4)) + defer f(T4{}) + panic(12) +} + +// enormous receiver, so wrapper splits stack to call M +type T5 [8192]byte + +func (T5) M() { + mustRecoverBody(doubleRecover(), recover(), recover(), 13) +} + +func test13() { + var i I = T5{} + defer i.M() + panic(13) +} + +func test13reflect1() { + f := reflect.ValueOf(T5{}).Method(0).Interface().(func()) + defer f() + panic(13) +} + +func test13reflect2() { + f := reflect.TypeOf(T5{}).Method(0).Func.Interface().(func(T5)) + defer f(T5{}) + panic(13) +} + +// enormous receiver + enormous method frame, so wrapper splits stack to call M, +// and then M splits stack to allocate its frame. +// recover must look back two frames to find the panic. +type T6 [8192]byte + +var global byte + +func (T6) M() { + var x [8192]byte + x[0] = 1 + x[1] = 2 + for i := range x { + global += x[i] + } + mustRecoverBody(doubleRecover(), recover(), recover(), 14) +} + +func test14() { + var i I = T6{} + defer i.M() + panic(14) +} + +func test14reflect1() { + f := reflect.ValueOf(T6{}).Method(0).Interface().(func()) + defer f() + panic(14) +} + +func test14reflect2() { + f := reflect.TypeOf(T6{}).Method(0).Func.Interface().(func(T6)) + defer f(T6{}) + panic(14) +} + +// function created by reflect.MakeFunc + +func reflectFunc(args []reflect.Value) (results []reflect.Value) { + mustRecoverBody(doubleRecover(), recover(), recover(), 15) + return nil +} + +func test15() { + f := reflect.MakeFunc(reflect.TypeOf((func())(nil)), reflectFunc).Interface().(func()) + defer f() + panic(15) +} diff --git a/test/recover3.go b/test/recover3.go index ebfa0a307..e17bfb3f6 100644 --- a/test/recover3.go +++ b/test/recover3.go @@ -64,7 +64,8 @@ func main() { i = 99999 var sl []int - check("array-bounds", func() { println(p[i]) }, "index out of range") + p1 := new([10]int) + check("array-bounds", func() { println(p1[i]) }, "index out of range") check("slice-bounds", func() { println(sl[i]) }, "index out of range") var inter interface{} diff --git a/test/return.go b/test/return.go index dcf32f86f..482f22bd5 100644 --- a/test/return.go +++ b/test/return.go @@ -272,7 +272,6 @@ func _() int { } // ERROR "missing return" func _() int { -L: print(1) if x == nil { panic(2) @@ -666,17 +665,6 @@ func _() int { } } -func _() int { - print(1) - switch x.(type) { - case int: - print(2) - fallthrough - default: - return 4 - } -} - // if no default or some case doesn't terminate, switch is no longer okay func _() int { @@ -713,17 +701,6 @@ func _() int { switch x.(type) { case int: print(2) - fallthrough - case float64: - return 4 - } -} // ERROR "missing return" - -func _() int { - print(1) - switch x.(type) { - case int: - print(2) panic(3) } } // ERROR "missing return" @@ -994,7 +971,6 @@ func _() int { } // ERROR "missing return" func _() int { -L: if x == nil { panic(2) } else if x == 1 { @@ -1356,16 +1332,6 @@ func _() int { } } -func _() int { - switch x.(type) { - case int: - print(2) - fallthrough - default: - return 4 - } -} - // if no default or some case doesn't terminate, switch is no longer okay func _() int { @@ -1398,16 +1364,6 @@ func _() int { switch x.(type) { case int: print(2) - fallthrough - case float64: - return 4 - } -} // ERROR "missing return" - -func _() int { - switch x.(type) { - case int: - print(2) panic(3) } } // ERROR "missing return" @@ -1450,6 +1406,16 @@ L: } } // ERROR "missing return" +func _() int { + switch x.(type) { + default: + return 4 + case int, float64: + print(2) + panic(3) + } +} + // again, with func literals var _ = func() int { @@ -1708,7 +1674,6 @@ var _ = func() int { } // ERROR "missing return" var _ = func() int { -L: print(1) if x == nil { panic(2) @@ -2102,17 +2067,6 @@ var _ = func() int { } } -var _ = func() int { - print(1) - switch x.(type) { - case int: - print(2) - fallthrough - default: - return 4 - } -} - // if no default or some case doesn't terminate, switch is no longer okay var _ = func() int { @@ -2149,17 +2103,6 @@ var _ = func() int { switch x.(type) { case int: print(2) - fallthrough - case float64: - return 4 - } -} // ERROR "missing return" - -var _ = func() int { - print(1) - switch x.(type) { - case int: - print(2) panic(3) } } // ERROR "missing return" @@ -2430,7 +2373,6 @@ var _ = func() int { } // ERROR "missing return" var _ = func() int { -L: if x == nil { panic(2) } else if x == 1 { @@ -2792,16 +2734,6 @@ var _ = func() int { } } -var _ = func() int { - switch x.(type) { - case int: - print(2) - fallthrough - default: - return 4 - } -} - // if no default or some case doesn't terminate, switch is no longer okay var _ = func() int { @@ -2834,16 +2766,6 @@ var _ = func() int { switch x.(type) { case int: print(2) - fallthrough - case float64: - return 4 - } -} // ERROR "missing return" - -var _ = func() int { - switch x.(type) { - case int: - print(2) panic(3) } } // ERROR "missing return" @@ -2886,4 +2808,14 @@ L: } } // ERROR "missing return" +var _ = func() int { + switch x.(type) { + default: + return 4 + case int, float64: + print(2) + panic(3) + } +} + /**/ diff --git a/test/run.go b/test/run.go index 5e167d6b0..f1f1ec034 100644 --- a/test/run.go +++ b/test/run.go @@ -27,6 +27,7 @@ import ( "sort" "strconv" "strings" + "unicode" ) var ( @@ -134,7 +135,7 @@ func main() { if !*verbose && test.err == nil { continue } - fmt.Printf("%-20s %-20s: %s\n", test.action, test.goFileName(), errStr) + fmt.Printf("# go run run.go -- %s\n%-20s %-20s: %s\n", path.Join(test.dir, test.gofile), test.action, test.goFileName(), errStr) } if *summary { @@ -299,14 +300,17 @@ func goDirPackages(longdir string) ([][]string, error) { return pkgs, nil } +type context struct { + GOOS string + GOARCH string +} + // shouldTest looks for build tags in a source file and returns // whether the file should be used according to the tags. func shouldTest(src string, goos, goarch string) (ok bool, whyNot string) { if idx := strings.Index(src, "\npackage"); idx >= 0 { src = src[:idx] } - notgoos := "!" + goos - notgoarch := "!" + goarch for _, line := range strings.Split(src, "\n") { line = strings.TrimSpace(line) if strings.HasPrefix(line, "//") { @@ -318,29 +322,59 @@ func shouldTest(src string, goos, goarch string) (ok bool, whyNot string) { if len(line) == 0 || line[0] != '+' { continue } + ctxt := &context{ + GOOS: goos, + GOARCH: goarch, + } words := strings.Fields(line) if words[0] == "+build" { - for _, word := range words { - switch word { - case goos, goarch: - return true, "" - case notgoos, notgoarch: - continue - default: - if word[0] == '!' { - // NOT something-else - return true, "" - } + ok := false + for _, word := range words[1:] { + if ctxt.match(word) { + ok = true + break } } - // no matching tag found. - return false, line + if !ok { + // no matching tag found. + return false, line + } } } - // no build tags. + // no build tags return true, "" } +func (ctxt *context) match(name string) bool { + if name == "" { + return false + } + if i := strings.Index(name, ","); i >= 0 { + // comma-separated list + return ctxt.match(name[:i]) && ctxt.match(name[i+1:]) + } + if strings.HasPrefix(name, "!!") { // bad syntax, reject always + return false + } + if strings.HasPrefix(name, "!") { // negation + return len(name) > 1 && !ctxt.match(name[1:]) + } + + // Tags must be letters, digits, underscores or dots. + // Unlike in Go identifiers, all digits are fine (e.g., "386"). + for _, c := range name { + if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' { + return false + } + } + + if name == ctxt.GOOS || name == ctxt.GOARCH { + return true + } + + return false +} + func init() { checkShouldTest() } // run runs a test. @@ -815,7 +849,7 @@ func defaultRunOutputLimit() int { return cpu } -// checkShouldTest runs canity checks on the shouldTest function. +// checkShouldTest runs sanity checks on the shouldTest function. func checkShouldTest() { assert := func(ok bool, _ string) { if !ok { @@ -823,11 +857,28 @@ func checkShouldTest() { } } assertNot := func(ok bool, _ string) { assert(!ok, "") } + + // Simple tests. assert(shouldTest("// +build linux", "linux", "arm")) assert(shouldTest("// +build !windows", "linux", "arm")) assertNot(shouldTest("// +build !windows", "windows", "amd64")) - assertNot(shouldTest("// +build arm 386", "linux", "amd64")) + + // A file with no build tags will always be tested. assert(shouldTest("// This is a test.", "os", "arch")) + + // Build tags separated by a space are OR-ed together. + assertNot(shouldTest("// +build arm 386", "linux", "amd64")) + + // Build tags seperated by a comma are AND-ed together. + assertNot(shouldTest("// +build !windows,!plan9", "windows", "amd64")) + assertNot(shouldTest("// +build !windows,!plan9", "plan9", "386")) + + // Build tags on multiple lines are AND-ed together. + assert(shouldTest("// +build !windows\n// +build amd64", "linux", "amd64")) + assertNot(shouldTest("// +build !windows\n// +build amd64", "windows", "amd64")) + + // Test that (!a OR !b) matches anything. + assert(shouldTest("// +build !windows !plan9", "windows", "amd64")) } // envForDir returns a copy of the environment diff --git a/test/shift1.go b/test/shift1.go index 71f7861c6..44a3792c4 100644 --- a/test/shift1.go +++ b/test/shift1.go @@ -23,7 +23,7 @@ var ( // non-constant shift expressions var ( - e1 = g(2.0 << s) // ERROR "invalid" "as type interface" + e1 = g(2.0 << s) // ERROR "invalid|shift of non-integer operand" "as type interface" f1 = h(2 << s) // ERROR "invalid" "as type float64" g1 int64 = 1.1 << s // ERROR "truncated" ) @@ -39,12 +39,12 @@ var ( var ( // issues 4882, 4936. - a3 = 1.0<<s + 0 // ERROR "invalid operation|shift of non-integer operand" + a3 = 1.0<<s + 0 // ERROR "invalid|shift of non-integer operand" // issue 4937 - b3 = 1<<s + 1 + 1.0 // ERROR "invalid operation|shift of non-integer operand" + b3 = 1<<s + 1 + 1.0 // ERROR "invalid|shift of non-integer operand" // issue 5014 - c3 = complex(1<<s, 0) // ERROR "shift of type float64" - d3 int = complex(1<<s, 3) // ERROR "cannot use.*as type int" "shift of type float64" + c3 = complex(1<<s, 0) // ERROR "invalid|shift of type float64" + d3 int = complex(1<<s, 3) // ERROR "non-integer|cannot use.*as type int" "shift of type float64" e3 = real(1 << s) // ERROR "invalid" f3 = imag(1 << s) // ERROR "invalid" ) @@ -61,60 +61,61 @@ func _() { o = 1<<s == 2<<s // 1 and 2 have type int; o == true if ints are 32bits in size // next test only fails on 32bit systems // p = 1<<s == 1<<33 // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int - u = 1.0 << s // ERROR "float64" - u1 = 1.0<<s != 0 // ERROR "float64" - u2 = 1<<s != 1.0 // ERROR "float64" - v float32 = 1 << s // ERROR "float32" + u = 1.0 << s // ERROR "non-integer|float64" + u1 = 1.0<<s != 0 // ERROR "non-integer|float64" + u2 = 1<<s != 1.0 // ERROR "non-integer|float64" + v float32 = 1 << s // ERROR "non-integer|float32" w int64 = 1.0 << 33 // 1.0<<33 is a constant shift expression + _, _, _, _, _, _, _, _, _, _ = j, k, m, n, o, u, u1, u2, v, w ) } // shifts in comparisons w/ untyped operands var ( _ = 1<<s == 1 - _ = 1<<s == 1. // ERROR "shift of type float64" - _ = 1.<<s == 1 // ERROR "shift of type float64" - _ = 1.<<s == 1. // ERROR "shift of type float64" + _ = 1<<s == 1. // ERROR "invalid|shift of type float64" + _ = 1.<<s == 1 // ERROR "invalid|shift of type float64" + _ = 1.<<s == 1. // ERROR "invalid|non-integer|shift of type float64" _ = 1<<s+1 == 1 - _ = 1<<s+1 == 1. // ERROR "shift of type float64" - _ = 1<<s+1. == 1 // ERROR "shift of type float64" - _ = 1<<s+1. == 1. // ERROR "shift of type float64" - _ = 1.<<s+1 == 1 // ERROR "shift of type float64" - _ = 1.<<s+1 == 1. // ERROR "shift of type float64" - _ = 1.<<s+1. == 1 // ERROR "shift of type float64" - _ = 1.<<s+1. == 1. // ERROR "shift of type float64" + _ = 1<<s+1 == 1. // ERROR "invalid|shift of type float64" + _ = 1<<s+1. == 1 // ERROR "invalid|shift of type float64" + _ = 1<<s+1. == 1. // ERROR "invalid|shift of type float64" + _ = 1.<<s+1 == 1 // ERROR "invalid|shift of type float64" + _ = 1.<<s+1 == 1. // ERROR "invalid|shift of type float64" + _ = 1.<<s+1. == 1 // ERROR "invalid|shift of type float64" + _ = 1.<<s+1. == 1. // ERROR "invalid|non-integer|shift of type float64" _ = 1<<s == 1<<s - _ = 1<<s == 1.<<s // ERROR "shift of type float64" - _ = 1.<<s == 1<<s // ERROR "shift of type float64" - _ = 1.<<s == 1.<<s // ERROR "shift of type float64" + _ = 1<<s == 1.<<s // ERROR "invalid|shift of type float64" + _ = 1.<<s == 1<<s // ERROR "invalid|shift of type float64" + _ = 1.<<s == 1.<<s // ERROR "invalid|non-integer|shift of type float64" _ = 1<<s+1<<s == 1 - _ = 1<<s+1<<s == 1. // ERROR "shift of type float64" - _ = 1<<s+1.<<s == 1 // ERROR "shift of type float64" - _ = 1<<s+1.<<s == 1. // ERROR "shift of type float64" - _ = 1.<<s+1<<s == 1 // ERROR "shift of type float64" - _ = 1.<<s+1<<s == 1. // ERROR "shift of type float64" - _ = 1.<<s+1.<<s == 1 // ERROR "shift of type float64" - _ = 1.<<s+1.<<s == 1. // ERROR "shift of type float64" + _ = 1<<s+1<<s == 1. // ERROR "invalid|shift of type float64" + _ = 1<<s+1.<<s == 1 // ERROR "invalid|shift of type float64" + _ = 1<<s+1.<<s == 1. // ERROR "invalid|shift of type float64" + _ = 1.<<s+1<<s == 1 // ERROR "invalid|shift of type float64" + _ = 1.<<s+1<<s == 1. // ERROR "invalid|shift of type float64" + _ = 1.<<s+1.<<s == 1 // ERROR "invalid|shift of type float64" + _ = 1.<<s+1.<<s == 1. // ERROR "invalid|non-integer|shift of type float64" _ = 1<<s+1<<s == 1<<s+1<<s - _ = 1<<s+1<<s == 1<<s+1.<<s // ERROR "shift of type float64" - _ = 1<<s+1<<s == 1.<<s+1<<s // ERROR "shift of type float64" - _ = 1<<s+1<<s == 1.<<s+1.<<s // ERROR "shift of type float64" - _ = 1<<s+1.<<s == 1<<s+1<<s // ERROR "shift of type float64" - _ = 1<<s+1.<<s == 1<<s+1.<<s // ERROR "shift of type float64" - _ = 1<<s+1.<<s == 1.<<s+1<<s // ERROR "shift of type float64" - _ = 1<<s+1.<<s == 1.<<s+1.<<s // ERROR "shift of type float64" - _ = 1.<<s+1<<s == 1<<s+1<<s // ERROR "shift of type float64" - _ = 1.<<s+1<<s == 1<<s+1.<<s // ERROR "shift of type float64" - _ = 1.<<s+1<<s == 1.<<s+1<<s // ERROR "shift of type float64" - _ = 1.<<s+1<<s == 1.<<s+1.<<s // ERROR "shift of type float64" - _ = 1.<<s+1.<<s == 1<<s+1<<s // ERROR "shift of type float64" - _ = 1.<<s+1.<<s == 1<<s+1.<<s // ERROR "shift of type float64" - _ = 1.<<s+1.<<s == 1.<<s+1<<s // ERROR "shift of type float64" - _ = 1.<<s+1.<<s == 1.<<s+1.<<s // ERROR "shift of type float64" + _ = 1<<s+1<<s == 1<<s+1.<<s // ERROR "invalid|shift of type float64" + _ = 1<<s+1<<s == 1.<<s+1<<s // ERROR "invalid|shift of type float64" + _ = 1<<s+1<<s == 1.<<s+1.<<s // ERROR "invalid|shift of type float64" + _ = 1<<s+1.<<s == 1<<s+1<<s // ERROR "invalid|shift of type float64" + _ = 1<<s+1.<<s == 1<<s+1.<<s // ERROR "invalid|shift of type float64" + _ = 1<<s+1.<<s == 1.<<s+1<<s // ERROR "invalid|shift of type float64" + _ = 1<<s+1.<<s == 1.<<s+1.<<s // ERROR "invalid|non-integer|shift of type float64" + _ = 1.<<s+1<<s == 1<<s+1<<s // ERROR "invalid|shift of type float64" + _ = 1.<<s+1<<s == 1<<s+1.<<s // ERROR "invalid|shift of type float64" + _ = 1.<<s+1<<s == 1.<<s+1<<s // ERROR "invalid|shift of type float64" + _ = 1.<<s+1<<s == 1.<<s+1.<<s // ERROR "invalid|non-integer|shift of type float64" + _ = 1.<<s+1.<<s == 1<<s+1<<s // ERROR "invalid|shift of type float64" + _ = 1.<<s+1.<<s == 1<<s+1.<<s // ERROR "invalid|non-integer|shift of type float64" + _ = 1.<<s+1.<<s == 1.<<s+1<<s // ERROR "invalid|non-integer|shift of type float64" + _ = 1.<<s+1.<<s == 1.<<s+1.<<s // ERROR "invalid|non-integer|shift of type float64" ) // shifts in comparisons w/ typed operands @@ -122,21 +123,21 @@ var ( x int _ = 1<<s == x _ = 1.<<s == x - _ = 1.1<<s == x // ERROR "1.1 truncated" + _ = 1.1<<s == x // ERROR "truncated" _ = 1<<s+x == 1 _ = 1<<s+x == 1. - _ = 1<<s+x == 1.1 // ERROR "1.1 truncated" + _ = 1<<s+x == 1.1 // ERROR "truncated" _ = 1.<<s+x == 1 _ = 1.<<s+x == 1. - _ = 1.<<s+x == 1.1 // ERROR "1.1 truncated" - _ = 1.1<<s+x == 1 // ERROR "1.1 truncated" - _ = 1.1<<s+x == 1. // ERROR "1.1 truncated" - _ = 1.1<<s+x == 1.1 // ERROR "1.1 truncated" + _ = 1.<<s+x == 1.1 // ERROR "truncated" + _ = 1.1<<s+x == 1 // ERROR "truncated" + _ = 1.1<<s+x == 1. // ERROR "truncated" + _ = 1.1<<s+x == 1.1 // ERROR "truncated" _ = 1<<s == x<<s _ = 1.<<s == x<<s - _ = 1.1<<s == x<<s // ERROR "1.1 truncated" + _ = 1.1<<s == x<<s // ERROR "truncated" ) // shifts as operands in non-arithmetic operations and as arguments @@ -146,43 +147,43 @@ func _() { _ = a[1<<s] _ = a[1.] // For now, the spec disallows these. We may revisit past Go 1.1. - _ = a[1.<<s] // ERROR "shift of type float64" - _ = a[1.1<<s] // ERROR "shift of type float64" + _ = a[1.<<s] // ERROR "integer|shift of type float64" + _ = a[1.1<<s] // ERROR "integer|shift of type float64" _ = make([]int, 1) _ = make([]int, 1.) _ = make([]int, 1.<<s) - _ = make([]int, 1.1<<s) // ERROR "1.1 truncated" + _ = make([]int, 1.1<<s) // ERROR "non-integer|truncated" _ = float32(1) - _ = float32(1 << s) // ERROR "shift of type float32" + _ = float32(1 << s) // ERROR "non-integer|shift of type float32" _ = float32(1.) - _ = float32(1. << s) // ERROR "shift of type float32" - _ = float32(1.1 << s) // ERROR "shift of type float32" + _ = float32(1. << s) // ERROR "non-integer|shift of type float32" + _ = float32(1.1 << s) // ERROR "non-integer|shift of type float32" _ = append(a, 1<<s) _ = append(a, 1.<<s) - _ = append(a, 1.1<<s) // ERROR "1.1 truncated" + _ = append(a, 1.1<<s) // ERROR "truncated" var b []float32 - _ = append(b, 1<<s) // ERROR "type float32" - _ = append(b, 1.<<s) // ERROR "type float32" - _ = append(b, 1.1<<s) // ERROR "type float32" + _ = append(b, 1<<s) // ERROR "non-integer|type float32" + _ = append(b, 1.<<s) // ERROR "non-integer|type float32" + _ = append(b, 1.1<<s) // ERROR "non-integer|type float32" - _ = complex(1.<<s, 0) // ERROR "shift of type float64" - _ = complex(1.1<<s, 0) // ERROR "shift of type float64" - _ = complex(0, 1.<<s) // ERROR "shift of type float64" - _ = complex(0, 1.1<<s) // ERROR "shift of type float64" + _ = complex(1.<<s, 0) // ERROR "non-integer|shift of type float64" + _ = complex(1.1<<s, 0) // ERROR "non-integer|shift of type float64" + _ = complex(0, 1.<<s) // ERROR "non-integer|shift of type float64" + _ = complex(0, 1.1<<s) // ERROR "non-integer|shift of type float64" var a4 float64 var b4 int - _ = complex(1<<s, a4) // ERROR "shift of type float64" - _ = complex(1<<s, b4) // ERROR "invalid" + _ = complex(1<<s, a4) // ERROR "non-integer|shift of type float64" + _ = complex(1<<s, b4) // ERROR "invalid|non-integer|" var m1 map[int]string delete(m1, 1<<s) delete(m1, 1.<<s) - delete(m1, 1.1<<s) // ERROR "1.1 truncated|shift of type float64" + delete(m1, 1.1<<s) // ERROR "truncated|shift of type float64" var m2 map[float32]string delete(m2, 1<<s) // ERROR "invalid|cannot use 1 << s as type float32" @@ -195,46 +196,46 @@ func _() { var s uint _ = 1 << (1 << s) _ = 1 << (1. << s) - _ = 1 << (1.1 << s) // ERROR "1.1 truncated" - _ = 1. << (1 << s) // ERROR "shift of type float64" - _ = 1. << (1. << s) // ERROR "shift of type float64" - _ = 1.1 << (1.1 << s) // ERROR "invalid|1.1 truncated" + _ = 1 << (1.1 << s) // ERROR "non-integer|truncated" + _ = 1. << (1 << s) // ERROR "non-integer|shift of type float64" + _ = 1. << (1. << s) // ERROR "non-integer|shift of type float64" + _ = 1.1 << (1.1 << s) // ERROR "invalid|non-integer|truncated" _ = (1 << s) << (1 << s) _ = (1 << s) << (1. << s) - _ = (1 << s) << (1.1 << s) // ERROR "1.1 truncated" - _ = (1. << s) << (1 << s) // ERROR "shift of type float64" - _ = (1. << s) << (1. << s) // ERROR "shift of type float64" - _ = (1.1 << s) << (1.1 << s) // ERROR "invalid|1.1 truncated" + _ = (1 << s) << (1.1 << s) // ERROR "truncated" + _ = (1. << s) << (1 << s) // ERROR "non-integer|shift of type float64" + _ = (1. << s) << (1. << s) // ERROR "non-integer|shift of type float64" + _ = (1.1 << s) << (1.1 << s) // ERROR "invalid|non-integer|truncated" var x int x = 1 << (1 << s) x = 1 << (1. << s) - x = 1 << (1.1 << s) // ERROR "1.1 truncated" + x = 1 << (1.1 << s) // ERROR "truncated" x = 1. << (1 << s) x = 1. << (1. << s) - x = 1.1 << (1.1 << s) // ERROR "1.1 truncated" + x = 1.1 << (1.1 << s) // ERROR "truncated" x = (1 << s) << (1 << s) x = (1 << s) << (1. << s) - x = (1 << s) << (1.1 << s) // ERROR "1.1 truncated" + x = (1 << s) << (1.1 << s) // ERROR "truncated" x = (1. << s) << (1 << s) x = (1. << s) << (1. << s) - x = (1.1 << s) << (1.1 << s) // ERROR "1.1 truncated" + x = (1.1 << s) << (1.1 << s) // ERROR "truncated" var y float32 - y = 1 << (1 << s) // ERROR "type float32" - y = 1 << (1. << s) // ERROR "type float32" - y = 1 << (1.1 << s) // ERROR "invalid|1.1 truncated|float32" - y = 1. << (1 << s) // ERROR "type float32" - y = 1. << (1. << s) // ERROR "type float32" - y = 1.1 << (1.1 << s) // ERROR "invalid|1.1 truncated|float32" + y = 1 << (1 << s) // ERROR "non-integer|type float32" + y = 1 << (1. << s) // ERROR "non-integer|type float32" + y = 1 << (1.1 << s) // ERROR "invalid|truncated|float32" + y = 1. << (1 << s) // ERROR "non-integer|type float32" + y = 1. << (1. << s) // ERROR "non-integer|type float32" + y = 1.1 << (1.1 << s) // ERROR "invalid|truncated|float32" var z complex128 - z = (1 << s) << (1 << s) // ERROR "type complex128" - z = (1 << s) << (1. << s) // ERROR "type complex128" - z = (1 << s) << (1.1 << s) // ERROR "invalid|1.1 truncated|complex128" - z = (1. << s) << (1 << s) // ERROR "type complex128" - z = (1. << s) << (1. << s) // ERROR "type complex128" - z = (1.1 << s) << (1.1 << s) // ERROR "invalid|1.1 truncated|complex128" + z = (1 << s) << (1 << s) // ERROR "non-integer|type complex128" + z = (1 << s) << (1. << s) // ERROR "non-integer|type complex128" + z = (1 << s) << (1.1 << s) // ERROR "invalid|truncated|complex128" + z = (1. << s) << (1 << s) // ERROR "non-integer|type complex128" + z = (1. << s) << (1. << s) // ERROR "non-integer|type complex128" + z = (1.1 << s) << (1.1 << s) // ERROR "invalid|truncated|complex128" } diff --git a/test/shift2.go b/test/shift2.go index 88ef3c40f..80e6bbc19 100644 --- a/test/shift2.go +++ b/test/shift2.go @@ -20,6 +20,7 @@ var ( i = 1 << s // 1 has type int j int32 = 1 << s // 1 has type int32; j == 0 k = uint64(1 << s) // 1 has type uint64; k == 1<<33 + l = g(1 << s) // 1 has type int m int = 1.0 << s // legal: 1.0 has type int w int64 = 1.0 << 33 // legal: 1.0<<33 is a constant shift expression ) diff --git a/test/sizeof.go b/test/sizeof.go index 9aa95677d..c3db1e5c3 100644 --- a/test/sizeof.go +++ b/test/sizeof.go @@ -1,4 +1,4 @@ -// compile +// run // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style @@ -58,35 +58,35 @@ func main() { type ( S1 struct { - A int32 + A int64 S2 } S2 struct { - B int32 + B int64 S3 } S3 struct { - C int32 + C int64 S4 } S4 struct { - D int32 + D int64 S5 } S5 struct { - E int32 + E int64 S6 } S6 struct { - F int32 + F int64 S7 } S7 struct { - G int32 + G int64 S8 } S8 struct { - H int32 + H int64 *S1 } ) @@ -96,24 +96,24 @@ func testDeep() { switch { case unsafe.Offsetof(s1.A) != 0: panic("unsafe.Offsetof(s1.A) != 0") - case unsafe.Offsetof(s1.B) != 4: - panic("unsafe.Offsetof(s1.B) != 4") - case unsafe.Offsetof(s1.C) != 8: - panic("unsafe.Offsetof(s1.C) != 8") - case unsafe.Offsetof(s1.D) != 12: - panic("unsafe.Offsetof(s1.D) != 12") - case unsafe.Offsetof(s1.E) != 16: - panic("unsafe.Offsetof(s1.E) != 16") - case unsafe.Offsetof(s1.F) != 20: - panic("unsafe.Offsetof(s1.F) != 20") - case unsafe.Offsetof(s1.G) != 24: - panic("unsafe.Offsetof(s1.G) != 24") - case unsafe.Offsetof(s1.H) != 28: - panic("unsafe.Offsetof(s1.H) != 28") - case unsafe.Offsetof(s1.S1) != 32: - panic("unsafe.Offsetof(s1.S1) != 32") - case unsafe.Offsetof(s1.S1.S2.S3.S4.S5.S6.S7.S8.S1.S2) != 4: - panic("unsafe.Offsetof(s1.S1.S2.S3.S4.S5.S6.S7.S8.S1.S2) != 4") + case unsafe.Offsetof(s1.B) != 8: + panic("unsafe.Offsetof(s1.B) != 8") + case unsafe.Offsetof(s1.C) != 16: + panic("unsafe.Offsetof(s1.C) != 16") + case unsafe.Offsetof(s1.D) != 24: + panic("unsafe.Offsetof(s1.D) != 24") + case unsafe.Offsetof(s1.E) != 32: + panic("unsafe.Offsetof(s1.E) != 32") + case unsafe.Offsetof(s1.F) != 40: + panic("unsafe.Offsetof(s1.F) != 40") + case unsafe.Offsetof(s1.G) != 48: + panic("unsafe.Offsetof(s1.G) != 48") + case unsafe.Offsetof(s1.H) != 56: + panic("unsafe.Offsetof(s1.H) != 56") + case unsafe.Offsetof(s1.S1) != 64: + panic("unsafe.Offsetof(s1.S1) != 64") + case unsafe.Offsetof(s1.S1.S2.S3.S4.S5.S6.S7.S8.S1.S2) != 8: + panic("unsafe.Offsetof(s1.S1.S2.S3.S4.S5.S6.S7.S8.S1.S2) != 8") } } diff --git a/test/slice3.go b/test/slice3.go new file mode 100644 index 000000000..3cf34b57e --- /dev/null +++ b/test/slice3.go @@ -0,0 +1,156 @@ +// runoutput + +// Copyright 2013 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. + +// Test run-time behavior of 3-index slice expressions. + +package main + +import ( + "bufio" + "fmt" + "os" + "strconv" +) + +var bout *bufio.Writer + +func main() { + bout = bufio.NewWriter(os.Stdout) + + fmt.Fprintf(bout, "%s", programTop) + fmt.Fprintf(bout, "func main() {\n") + + index := []string{ + "0", + "1", + "2", + "3", + "10", + "20", + "vminus1", + "v0", + "v1", + "v2", + "v3", + "v10", + "v20", + } + + parse := func(s string) (n int, isconst bool) { + if s == "vminus1" { + return -1, false + } + isconst = true + if s[0] == 'v' { + isconst = false + s = s[1:] + } + n, _ = strconv.Atoi(s) + return n, isconst + } + + const Cap = 10 // cap of slice, array + + for _, base := range []string{"array", "slice"} { + for _, i := range index { + iv, iconst := parse(i) + for _, j := range index { + jv, jconst := parse(j) + for _, k := range index { + kv, kconst := parse(k) + // Avoid errors that would make the program not compile. + // Those are tested by slice3err.go. + switch { + case iconst && jconst && iv > jv, + jconst && kconst && jv > kv, + iconst && kconst && iv > kv, + iconst && base == "array" && iv > Cap, + jconst && base == "array" && jv > Cap, + kconst && base == "array" && kv > Cap: + continue + } + + expr := base + "[" + i + ":" + j + ":" + k + "]" + var xbase, xlen, xcap int + if iv > jv || jv > kv || kv > Cap || iv < 0 || jv < 0 || kv < 0 { + xbase, xlen, xcap = -1, -1, -1 + } else { + xbase = iv + xlen = jv - iv + xcap = kv - iv + } + fmt.Fprintf(bout, "\tcheckSlice(%q, func() []byte { return %s }, %d, %d, %d)\n", expr, expr, xbase, xlen, xcap) + } + } + } + } + + fmt.Fprintf(bout, "\tif !ok { os.Exit(1) }\n") + fmt.Fprintf(bout, "}\n") + bout.Flush() +} + +var programTop = ` +package main + +import ( + "fmt" + "os" + "unsafe" +) + +var ok = true + +var ( + array = new([10]byte) + slice = array[:] + + vminus1 = -1 + v0 = 0 + v1 = 1 + v2 = 2 + v3 = 3 + v4 = 4 + v5 = 5 + v10 = 10 + v20 = 20 +) + +func notOK() { + if ok { + println("BUG:") + ok = false + } +} + +func checkSlice(desc string, f func() []byte, xbase, xlen, xcap int) { + defer func() { + if err := recover(); err != nil { + if xbase >= 0 { + notOK() + println(desc, " unexpected panic: ", fmt.Sprint(err)) + } + } + // "no panic" is checked below + }() + + x := f() + + arrayBase := uintptr(unsafe.Pointer(array)) + raw := *(*[3]uintptr)(unsafe.Pointer(&x)) + base, len, cap := raw[0] - arrayBase, raw[1], raw[2] + if xbase < 0 { + notOK() + println(desc, "=", base, len, cap, "want panic") + return + } + if base != uintptr(xbase) || len != uintptr(xlen) || cap != uintptr(xcap) { + notOK() + println(desc, "=", base, len, cap, "want", xbase, xlen, xcap) + } +} + +` diff --git a/test/slice3err.go b/test/slice3err.go new file mode 100644 index 000000000..906b00703 --- /dev/null +++ b/test/slice3err.go @@ -0,0 +1,121 @@ +// errorcheck + +// Copyright 2013 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. + +package p + +var array *[10]int +var slice []int +var str string +var i, j, k int + +func f() { + // check what missing arguments are allowed + _ = array[:] + _ = array[i:] + _ = array[:j] + _ = array[i:j] + _ = array[::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice" + _ = array[i::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice" + _ = array[:j:] // ERROR "final index required in 3-index slice" + _ = array[i:j:] // ERROR "final index required in 3-index slice" + _ = array[::k] // ERROR "middle index required in 3-index slice" + _ = array[i::k] // ERROR "middle index required in 3-index slice" + _ = array[:j:k] + _ = array[i:j:k] + + _ = slice[:] + _ = slice[i:] + _ = slice[:j] + _ = slice[i:j] + _ = slice[::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice" + _ = slice[i::] // ERROR "middle index required in 3-index slice" "final index required in 3-index slice" + _ = slice[:j:] // ERROR "final index required in 3-index slice" + _ = slice[i:j:] // ERROR "final index required in 3-index slice" + _ = slice[::k] // ERROR "middle index required in 3-index slice" + _ = slice[i::k] // ERROR "middle index required in 3-index slice" + _ = slice[:j:k] + _ = slice[i:j:k] + + _ = str[:] + _ = str[i:] + _ = str[:j] + _ = str[i:j] + _ = str[::] // ERROR "3-index slice of string" "middle index required in 3-index slice" "final index required in 3-index slice" + _ = str[i::] // ERROR "3-index slice of string" "middle index required in 3-index slice" "final index required in 3-index slice" + _ = str[:j:] // ERROR "3-index slice of string" "final index required in 3-index slice" + _ = str[i:j:] // ERROR "3-index slice of string" "final index required in 3-index slice" + _ = str[::k] // ERROR "3-index slice of string" "middle index required in 3-index slice" + _ = str[i::k] // ERROR "3-index slice of string" "middle index required in 3-index slice" + _ = str[:j:k] // ERROR "3-index slice of string" + _ = str[i:j:k] // ERROR "3-index slice of string" + + // check invalid indices + _ = array[1:2] + _ = array[2:1] // ERROR "invalid slice index" + _ = array[2:2] + _ = array[i:1] + _ = array[1:j] + _ = array[1:2:3] + _ = array[1:3:2] // ERROR "invalid slice index" + _ = array[2:1:3] // ERROR "invalid slice index" + _ = array[2:3:1] // ERROR "invalid slice index" + _ = array[3:1:2] // ERROR "invalid slice index" + _ = array[3:2:1] // ERROR "invalid slice index" + _ = array[i:1:2] + _ = array[i:2:1] // ERROR "invalid slice index" + _ = array[1:j:2] + _ = array[2:j:1] // ERROR "invalid slice index" + _ = array[1:2:k] + _ = array[2:1:k] // ERROR "invalid slice index" + + _ = slice[1:2] + _ = slice[2:1] // ERROR "invalid slice index" + _ = slice[2:2] + _ = slice[i:1] + _ = slice[1:j] + _ = slice[1:2:3] + _ = slice[1:3:2] // ERROR "invalid slice index" + _ = slice[2:1:3] // ERROR "invalid slice index" + _ = slice[2:3:1] // ERROR "invalid slice index" + _ = slice[3:1:2] // ERROR "invalid slice index" + _ = slice[3:2:1] // ERROR "invalid slice index" + _ = slice[i:1:2] + _ = slice[i:2:1] // ERROR "invalid slice index" + _ = slice[1:j:2] + _ = slice[2:j:1] // ERROR "invalid slice index" + _ = slice[1:2:k] + _ = slice[2:1:k] // ERROR "invalid slice index" + + _ = str[1:2] + _ = str[2:1] // ERROR "invalid slice index" + _ = str[2:2] + _ = str[i:1] + _ = str[1:j] + + // check out of bounds indices on array + _ = array[11:11] // ERROR "out of bounds for 10-element array" + _ = array[11:12] // ERROR "out of bounds for 10-element array" + _ = array[11:] // ERROR "out of bounds for 10-element array" + _ = array[:11] // ERROR "out of bounds for 10-element array" + _ = array[1:11] // ERROR "out of bounds for 10-element array" + _ = array[1:11:12] // ERROR "out of bounds for 10-element array" + _ = array[1:2:11] // ERROR "out of bounds for 10-element array" + _ = array[1:11:3] // ERROR "out of bounds for 10-element array" + _ = array[11:2:3] // ERROR "out of bounds for 10-element array" + _ = array[11:12:13] // ERROR "out of bounds for 10-element array" + + // slice bounds not checked + _ = slice[11:11] + _ = slice[11:12] + _ = slice[11:] + _ = slice[:11] + _ = slice[1:11] + _ = slice[1:11:12] + _ = slice[1:2:11] + _ = slice[1:11:3] // ERROR "invalid slice index" + _ = slice[11:2:3] // ERROR "invalid slice index" + _ = slice[11:12:13] +} diff --git a/test/stress/runstress.go b/test/stress/runstress.go index b5adf6a4a..76ab2a8b4 100644 --- a/test/stress/runstress.go +++ b/test/stress/runstress.go @@ -114,11 +114,16 @@ func stressExec() { } } -func ringf(in <-chan int, out chan<- int, donec chan<- bool) { +func ringf(in <-chan int, out chan<- int, donec chan bool) { for { - n := <-in + var n int + select { + case <-donec: + return + case n = <-in: + } if n == 0 { - donec <- true + close(donec) return } out <- n - 1 diff --git a/test/syntax/chan1.go b/test/syntax/chan1.go index 868a1226d..4860422ad 100644 --- a/test/syntax/chan1.go +++ b/test/syntax/chan1.go @@ -10,8 +10,8 @@ var c chan int var v int func main() { - if c <- v { // ERROR "send statement.*value.*select" + if c <- v { // ERROR "used as value" } } -var _ = c <- v // ERROR "send statement.*value.*select" +var _ = c <- v // ERROR "used as value" diff --git a/test/syntax/semi1.go b/test/syntax/semi1.go index 8fbfb206a..cc30f2654 100644 --- a/test/syntax/semi1.go +++ b/test/syntax/semi1.go @@ -7,7 +7,7 @@ package main func main() { - if x; y // ERROR "unexpected semicolon or newline before .?{.?|undefined" + if x; y // ERROR "missing { after if clause|undefined" { z // GCCGO_ERROR "undefined" diff --git a/test/syntax/semi2.go b/test/syntax/semi2.go index cfb0ed17b..61b8bf6d4 100644 --- a/test/syntax/semi2.go +++ b/test/syntax/semi2.go @@ -7,7 +7,7 @@ package main func main() { - switch x; y // ERROR "unexpected semicolon or newline before .?{.?|undefined" + switch x; y // ERROR "missing { after switch clause|undefined" { z diff --git a/test/syntax/semi3.go b/test/syntax/semi3.go index 645af7354..bb87520c5 100644 --- a/test/syntax/semi3.go +++ b/test/syntax/semi3.go @@ -7,7 +7,7 @@ package main func main() { - for x; y; z // ERROR "unexpected semicolon or newline before .?{.?|undefined" + for x; y; z // ERROR "missing { after for clause|undefined" { z // GCCGO_ERROR "undefined" diff --git a/test/syntax/semi4.go b/test/syntax/semi4.go index e192348aa..00fa3f575 100644 --- a/test/syntax/semi4.go +++ b/test/syntax/semi4.go @@ -8,7 +8,7 @@ package main func main() { for x // GCCGO_ERROR "undefined" - { // ERROR "unexpected semicolon or newline before .?{.?" + { // ERROR "missing { after for clause" z // GCCGO_ERROR "undefined" diff --git a/test/testlib b/test/testlib index de138b1d1..4a17f4feb 100644 --- a/test/testlib +++ b/test/testlib @@ -16,29 +16,50 @@ pkgs() { done | sort } +_match() { + case $1 in + *,*) + #echo >&2 "match comma separated $1" + first=$(echo $1 | sed 's/,.*//') + rest=$(echo $1 | sed 's/[^,]*,//') + if _match $first && _match $rest; then + return 0 + fi + return 1 + ;; + '!'*) + #echo >&2 "match negation $1" + neg=$(echo $1 | sed 's/^!//') + if _match $neg; then + return 1 + fi + return 0 + ;; + $GOARCH|$GOOS) + #echo >&2 "match GOARCH or GOOS $1" + return 0 + ;; + esac + return 1 +} + # +build aborts execution if the supplied tags don't match, # i.e. none of the tags (x or !x) matches GOARCH or GOOS. +build() { if (( $# == 0 )); then return fi + m=0 for tag; do - case $tag in - $GOARCH|$GOOS) - #echo >&2 "match $tag in $1" - return # don't exclude. - ;; - '!'$GOARCH|'!'$GOOS) - ;; - '!'*) - # not x where x is neither GOOS nor GOARCH. - #echo >&2 "match $tag in $1" - return # don't exclude - ;; - esac + if _match $tag; then + m=1 + fi done - # no match. - exit 0 + if [ $m = 0 ]; then + #echo >&2 no match + exit 0 + fi + unset m } compile() { |