Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

[dev.typeparams] cmd/compile/internal/types2: add testdata directory

Browse source 
Exact copy of src/go/types/testdata. Testdata tests still disabled.

Change-Id: Idff5fff7f1adcfd626f700b1f21f5a14ce1a74f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/263630
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Robert Griesemer 2020-10-19 21:10:37 -07:00
parent ca36ba83ab
commit befc62a2c4
36 changed files with 8564 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/cmd/compile/internal/types2/testdata/blank.src vendored Normal file
View file

@ -0,0 +1,5 @@
// Copyright 2014 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 _ /* ERROR invalid package name */

902
src/cmd/compile/internal/types2/testdata/builtins.src vendored Normal file
View file

@ -0,0 +1,902 @@
// 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.
// builtin calls
package builtins
import "unsafe"
func f0() {}
func append1() {
var b byte
var x int
var s []byte
_ = append() // ERROR not enough arguments
_ = append("foo" /* ERROR not a slice */ )
_ = append(nil /* ERROR not a slice */ , s)
_ = append(x /* ERROR not a slice */ , s)
_ = append(s)
_ = append(s, nil...)
append /* ERROR not used */ (s)
_ = append(s, b)
_ = append(s, x /* ERROR cannot use x */ )
_ = append(s, s /* ERROR cannot use s */ )
_ = append(s... /* ERROR can only use ... with matching parameter */ )
_ = append(s, b, s... /* ERROR can only use ... with matching parameter */ )
_ = append(s, 1, 2, 3)
_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
_ = append(s, 1, 2, s... /* ERROR can only use ... with matching parameter */ )
_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
type S []byte
type T string
var t T
_ = append(s, "foo" /* ERROR cannot convert */ )
_ = append(s, "foo"...)
_ = append(S(s), "foo" /* ERROR cannot convert */ )
_ = append(S(s), "foo"...)
_ = append(s, t /* ERROR cannot use t */ )
_ = append(s, t...)
_ = append(s, T("foo")...)
_ = append(S(s), t /* ERROR cannot use t */ )
_ = append(S(s), t...)
_ = append(S(s), T("foo")...)
_ = append([]string{}, t /* ERROR cannot use t */ , "foo")
_ = append([]T{}, t, "foo")
}
// from the spec
func append2() {
s0 := []int{0, 0}
s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2}
s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7}
s3 := append(s2, s0...) // append a slice s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
s4 := append(s3[3:6], s3[2:]...) // append overlapping slice s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}
var t []interface{}
t = append(t, 42, 3.1415, "foo") // t == []interface{}{42, 3.1415, "foo"}
var b []byte
b = append(b, "bar"...) // append string contents b == []byte{'b', 'a', 'r' }
_ = s4
}
func append3() {
f1 := func() (s []int) { return }
f2 := func() (s []int, x int) { return }
f3 := func() (s []int, x, y int) { return }
f5 := func() (s []interface{}, x int, y float32, z string, b bool) { return }
ff := func() (int, float32) { return 0, 0 }
_ = append(f0 /* ERROR used as value */ ())
_ = append(f1())
_ = append(f2())
_ = append(f3())
_ = append(f5())
_ = append(ff /* ERROR not a slice */ ()) // TODO(gri) better error message
}
func cap1() {
var a [10]bool
var p *[20]int
var c chan string
_ = cap() // ERROR not enough arguments
_ = cap(1, 2) // ERROR too many arguments
_ = cap(42 /* ERROR invalid */)
const _3 = cap(a)
assert(_3 == 10)
const _4 = cap(p)
assert(_4 == 20)
_ = cap(c)
cap /* ERROR not used */ (c)
// issue 4744
type T struct{ a [10]int }
const _ = cap(((*T)(nil)).a)
var s [][]byte
_ = cap(s)
_ = cap(s... /* ERROR invalid use of \.\.\. */ )
}
func cap2() {
f1a := func() (a [10]int) { return }
f1s := func() (s []int) { return }
f2 := func() (s []int, x int) { return }
_ = cap(f0 /* ERROR used as value */ ())
_ = cap(f1a())
_ = cap(f1s())
_ = cap(f2()) // ERROR too many arguments
}
// test cases for issue 7387
func cap3() {
var f = func() int { return 0 }
var x = f()
const (
_ = cap([4]int{})
_ = cap([4]int{x})
_ = cap /* ERROR not constant */ ([4]int{f()})
_ = cap /* ERROR not constant */ ([4]int{cap([]int{})})
_ = cap([4]int{cap([4]int{})})
)
var y float64
var z complex128
const (
_ = cap([4]float64{})
_ = cap([4]float64{y})
_ = cap([4]float64{real(2i)})
_ = cap /* ERROR not constant */ ([4]float64{real(z)})
)
var ch chan [10]int
const (
_ = cap /* ERROR not constant */ (<-ch)
_ = cap /* ERROR not constant */ ([4]int{(<-ch)[0]})
)
}
func close1() {
var c chan int
var r <-chan int
close() // ERROR not enough arguments
close(1, 2) // ERROR too many arguments
close(42 /* ERROR not a channel */)
close(r /* ERROR receive-only channel */)
close(c)
_ = close /* ERROR used as value */ (c)
var s []chan int
close(s... /* ERROR invalid use of \.\.\. */ )
}
func close2() {
f1 := func() (ch chan int) { return }
f2 := func() (ch chan int, x int) { return }
close(f0 /* ERROR used as value */ ())
close(f1())
close(f2()) // ERROR too many arguments
}
func complex1() {
var i32 int32
var f32 float32
var f64 float64
var c64 complex64
var c128 complex128
_ = complex() // ERROR not enough arguments
_ = complex(1) // ERROR not enough arguments
_ = complex(true /* ERROR mismatched types */ , 0)
_ = complex(i32 /* ERROR expected floating-point */ , 0)
_ = complex("foo" /* ERROR mismatched types */ , 0)
_ = complex(c64 /* ERROR expected floating-point */ , 0)
_ = complex(0 /* ERROR mismatched types */ , true)
_ = complex(0 /* ERROR expected floating-point */ , i32)
_ = complex(0 /* ERROR mismatched types */ , "foo")
_ = complex(0 /* ERROR expected floating-point */ , c64)
_ = complex(f32, f32)
_ = complex(f32, 1)
_ = complex(f32, 1.0)
_ = complex(f32, 'a')
_ = complex(f64, f64)
_ = complex(f64, 1)
_ = complex(f64, 1.0)
_ = complex(f64, 'a')
_ = complex(f32 /* ERROR mismatched types */ , f64)
_ = complex(f64 /* ERROR mismatched types */ , f32)
_ = complex(1, 1)
_ = complex(1, 1.1)
_ = complex(1, 'a')
complex /* ERROR not used */ (1, 2)
var _ complex64 = complex(f32, f32)
var _ complex64 = complex /* ERROR cannot use .* in variable declaration */ (f64, f64)
var _ complex128 = complex /* ERROR cannot use .* in variable declaration */ (f32, f32)
var _ complex128 = complex(f64, f64)
// untyped constants
const _ int = complex(1, 0)
const _ float32 = complex(1, 0)
const _ complex64 = complex(1, 0)
const _ complex128 = complex(1, 0)
const _ = complex(0i, 0i)
const _ = complex(0i, 0)
const _ int = 1.0 + complex(1, 0i)
const _ int = complex /* ERROR int */ (1.1, 0)
const _ float32 = complex /* ERROR float32 */ (1, 2)
// untyped values
var s uint
_ = complex(1 /* ERROR integer */ <<s, 0)
const _ = complex /* ERROR not constant */ (1 /* ERROR integer */ <<s, 0)
var _ int = complex /* ERROR cannot use .* in variable declaration */ (1 /* ERROR integer */ <<s, 0)
// floating-point argument types must be identical
type F32 float32
type F64 float64
var x32 F32
var x64 F64
c64 = complex(x32, x32)
_ = complex(x32 /* ERROR mismatched types */ , f32)
_ = complex(f32 /* ERROR mismatched types */ , x32)
c128 = complex(x64, x64)
_ = c128
_ = complex(x64 /* ERROR mismatched types */ , f64)
_ = complex(f64 /* ERROR mismatched types */ , x64)
var t []float32
_ = complex(t... /* ERROR invalid use of \.\.\. */ )
}
func complex2() {
f1 := func() (x float32) { return }
f2 := func() (x, y float32) { return }
f3 := func() (x, y, z float32) { return }
_ = complex(f0 /* ERROR used as value */ ())
_ = complex(f1()) // ERROR not enough arguments
_ = complex(f2())
_ = complex(f3()) // ERROR too many arguments
}
func copy1() {
copy() // ERROR not enough arguments
copy("foo") // ERROR not enough arguments
copy([ /* ERROR copy expects slice arguments */ ...]int{}, []int{})
copy([ /* ERROR copy expects slice arguments */ ]int{}, [...]int{})
copy([ /* ERROR different element types */ ]int8{}, "foo")
// spec examples
var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
var b = make([]byte, 5)
n1 := copy(s, a[0:]) // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:]) // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!") // n3 == 5, b == []byte("Hello")
_, _, _ = n1, n2, n3
var t [][]int
copy(t, t)
copy(t /* ERROR copy expects slice arguments */ , nil)
copy(nil /* ERROR copy expects slice arguments */ , t)
copy(nil /* ERROR copy expects slice arguments */ , nil)
copy(t... /* ERROR invalid use of \.\.\. */ )
}
func copy2() {
f1 := func() (a []int) { return }
f2 := func() (a, b []int) { return }
f3 := func() (a, b, c []int) { return }
copy(f0 /* ERROR used as value */ ())
copy(f1()) // ERROR not enough arguments
copy(f2())
copy(f3()) // ERROR too many arguments
}
func delete1() {
var m map[string]int
var s string
delete() // ERROR not enough arguments
delete(1) // ERROR not enough arguments
delete(1, 2, 3) // ERROR too many arguments
delete(m, 0 /* ERROR not assignable */)
delete(m, s)
_ = delete /* ERROR used as value */ (m, s)
var t []map[string]string
delete(t... /* ERROR invalid use of \.\.\. */ )
}
func delete2() {
f1 := func() (m map[string]int) { return }
f2 := func() (m map[string]int, k string) { return }
f3 := func() (m map[string]int, k string, x float32) { return }
delete(f0 /* ERROR used as value */ ())
delete(f1()) // ERROR not enough arguments
delete(f2())
delete(f3()) // ERROR too many arguments
}
func imag1() {
var f32 float32
var f64 float64
var c64 complex64
var c128 complex128
_ = imag() // ERROR not enough arguments
_ = imag(1, 2) // ERROR too many arguments
_ = imag(10)
_ = imag(2.7182818)
_ = imag("foo" /* ERROR expected complex */)
_ = imag('a')
const _5 = imag(1 + 2i)
assert(_5 == 2)
f32 = _5
f64 = _5
const _6 = imag(0i)
assert(_6 == 0)
f32 = imag(c64)
f64 = imag(c128)
f32 = imag /* ERROR cannot use .* in assignment */ (c128)
f64 = imag /* ERROR cannot use .* in assignment */ (c64)
imag /* ERROR not used */ (c64)
_, _ = f32, f64
// complex type may not be predeclared
type C64 complex64
type C128 complex128
var x64 C64
var x128 C128
f32 = imag(x64)
f64 = imag(x128)
var a []complex64
_ = imag(a... /* ERROR invalid use of \.\.\. */ )
// if argument is untyped, result is untyped
const _ byte = imag(1.2 + 3i)
const _ complex128 = imag(1.2 + 3i)
// lhs constant shift operands are typed as complex128
var s uint
_ = imag(1 /* ERROR must be integer */ << s)
}
func imag2() {
f1 := func() (x complex128) { return }
f2 := func() (x, y complex128) { return }
_ = imag(f0 /* ERROR used as value */ ())
_ = imag(f1())
_ = imag(f2()) // ERROR too many arguments
}
func len1() {
const c = "foobar"
var a [10]bool
var p *[20]int
var m map[string]complex128
_ = len() // ERROR not enough arguments
_ = len(1, 2) // ERROR too many arguments
_ = len(42 /* ERROR invalid */)
const _3 = len(c)
assert(_3 == 6)
const _4 = len(a)
assert(_4 == 10)
const _5 = len(p)
assert(_5 == 20)
_ = len(m)
len /* ERROR not used */ (c)
// esoteric case
var t string
var hash map[interface{}][]*[10]int
const n = len /* ERROR not constant */ (hash[recover()][len(t)])
assert(n == 10) // ok because n has unknown value and no error is reported
var ch <-chan int
const nn = len /* ERROR not constant */ (hash[<-ch][len(t)])
// issue 4744
type T struct{ a [10]int }
const _ = len(((*T)(nil)).a)
var s [][]byte
_ = len(s)
_ = len(s... /* ERROR invalid use of \.\.\. */ )
}
func len2() {
f1 := func() (x []int) { return }
f2 := func() (x, y []int) { return }
_ = len(f0 /* ERROR used as value */ ())
_ = len(f1())
_ = len(f2()) // ERROR too many arguments
}
// test cases for issue 7387
func len3() {
var f = func() int { return 0 }
var x = f()
const (
_ = len([4]int{})
_ = len([4]int{x})
_ = len /* ERROR not constant */ ([4]int{f()})
_ = len /* ERROR not constant */ ([4]int{len([]int{})})
_ = len([4]int{len([4]int{})})
)
var y float64
var z complex128
const (
_ = len([4]float64{})
_ = len([4]float64{y})
_ = len([4]float64{real(2i)})
_ = len /* ERROR not constant */ ([4]float64{real(z)})
)
var ch chan [10]int
const (
_ = len /* ERROR not constant */ (<-ch)
_ = len /* ERROR not constant */ ([4]int{(<-ch)[0]})
)
}
func make1() {
var n int
var m float32
var s uint
_ = make() // ERROR not enough arguments
_ = make(1 /* ERROR not a type */)
_ = make(int /* ERROR cannot make */)
// slices
_ = make/* ERROR arguments */ ([]int)
_ = make/* ERROR arguments */ ([]int, 2, 3, 4)
_ = make([]int, int /* ERROR not an expression */)
_ = make([]int, 10, float32 /* ERROR not an expression */)
_ = make([]int, "foo" /* ERROR cannot convert */)
_ = make([]int, 10, 2.3 /* ERROR truncated */)
_ = make([]int, 5, 10.0)
_ = make([]int, 0i)
_ = make([]int, 1.0)
_ = make([]int, 1.0<<s)
_ = make([]int, 1.1 /* ERROR int */ <<s)
_ = make([]int, - /* ERROR must not be negative */ 1, 10)
_ = make([]int, 0, - /* ERROR must not be negative */ 1)
_ = make([]int, - /* ERROR must not be negative */ 1, - /* ERROR must not be negative */ 1)
_ = make([]int, 1 /* ERROR overflows */ <<100, 1 /* ERROR overflows */ <<100)
_ = make([]int, 10 /* ERROR length and capacity swapped */ , 9)
_ = make([]int, 1 /* ERROR overflows */ <<100, 12345)
_ = make([]int, m /* ERROR must be integer */ )
_ = &make /* ERROR cannot take address */ ([]int, 0)
// maps
_ = make /* ERROR arguments */ (map[int]string, 10, 20)
_ = make(map[int]float32, int /* ERROR not an expression */)
_ = make(map[int]float32, "foo" /* ERROR cannot convert */)
_ = make(map[int]float32, 10)
_ = make(map[int]float32, n)
_ = make(map[int]float32, int64(n))
_ = make(map[string]bool, 10.0)
_ = make(map[string]bool, 10.0<<s)
_ = &make /* ERROR cannot take address */ (map[string]bool)
// channels
_ = make /* ERROR arguments */ (chan int, 10, 20)
_ = make(chan int, int /* ERROR not an expression */)
_ = make(chan<- int, "foo" /* ERROR cannot convert */)
_ = make(chan int, - /* ERROR must not be negative */ 10)
_ = make(<-chan float64, 10)
_ = make(chan chan int, n)
_ = make(chan string, int64(n))
_ = make(chan bool, 10.0)
_ = make(chan bool, 10.0<<s)
_ = &make /* ERROR cannot take address */ (chan bool)
make /* ERROR not used */ ([]int, 10)
var t []int
_ = make([]int, t[0], t[1])
_ = make([]int, t... /* ERROR invalid use of \.\.\. */ )
}
func make2() {
f1 /* ERROR not used */ := func() (x []int) { return }
_ = make(f0 /* ERROR not a type */ ())
_ = make(f1 /* ERROR not a type */ ())
}
func new1() {
_ = new() // ERROR not enough arguments
_ = new(1, 2) // ERROR too many arguments
_ = new("foo" /* ERROR not a type */)
p := new(float64)
_ = new(struct{ x, y int })
q := new(*float64)
_ = *p == **q
new /* ERROR not used */ (int)
_ = &new /* ERROR cannot take address */ (int)
_ = new(int... /* ERROR invalid use of \.\.\. */ )
}
func new2() {
f1 /* ERROR not used */ := func() (x []int) { return }
_ = new(f0 /* ERROR not a type */ ())
_ = new(f1 /* ERROR not a type */ ())
}
func panic1() {
panic() // ERROR not enough arguments
panic(1, 2) // ERROR too many arguments
panic(0)
panic("foo")
panic(false)
panic(1<<10)
panic(1 /* ERROR overflows */ <<1000)
_ = panic /* ERROR used as value */ (0)
var s []byte
panic(s)
panic(s... /* ERROR invalid use of \.\.\. */ )
}
func panic2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
panic(f0 /* ERROR used as value */ ())
panic(f1())
panic(f2()) // ERROR too many arguments
}
func print1() {
print()
print(1)
print(1, 2)
print("foo")
print(2.718281828)
print(false)
print(1<<10)
print(1 /* ERROR overflows */ <<1000)
println(nil /* ERROR untyped nil */ )
var s []int
print(s... /* ERROR invalid use of \.\.\. */ )
_ = print /* ERROR used as value */ ()
}
func print2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
f3 := func() (x int, y float32, z string) { return }
print(f0 /* ERROR used as value */ ())
print(f1())
print(f2())
print(f3())
}
func println1() {
println()
println(1)
println(1, 2)
println("foo")
println(2.718281828)
println(false)
println(1<<10)
println(1 /* ERROR overflows */ <<1000)
println(nil /* ERROR untyped nil */ )
var s []int
println(s... /* ERROR invalid use of \.\.\. */ )
_ = println /* ERROR used as value */ ()
}
func println2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
f3 := func() (x int, y float32, z string) { return }
println(f0 /* ERROR used as value */ ())
println(f1())
println(f2())
println(f3())
}
func real1() {
var f32 float32
var f64 float64
var c64 complex64
var c128 complex128
_ = real() // ERROR not enough arguments
_ = real(1, 2) // ERROR too many arguments
_ = real(10)
_ = real(2.7182818)
_ = real("foo" /* ERROR expected complex */)
const _5 = real(1 + 2i)
assert(_5 == 1)
f32 = _5
f64 = _5
const _6 = real(0i)
assert(_6 == 0)
f32 = real(c64)
f64 = real(c128)
f32 = real /* ERROR cannot use .* in assignment */ (c128)
f64 = real /* ERROR cannot use .* in assignment */ (c64)
real /* ERROR not used */ (c64)
// complex type may not be predeclared
type C64 complex64
type C128 complex128
var x64 C64
var x128 C128
f32 = imag(x64)
f64 = imag(x128)
_, _ = f32, f64
var a []complex64
_ = real(a... /* ERROR invalid use of \.\.\. */ )
// if argument is untyped, result is untyped
const _ byte = real(1 + 2.3i)
const _ complex128 = real(1 + 2.3i)
// lhs constant shift operands are typed as complex128
var s uint
_ = real(1 /* ERROR must be integer */ << s)
}
func real2() {
f1 := func() (x complex128) { return }
f2 := func() (x, y complex128) { return }
_ = real(f0 /* ERROR used as value */ ())
_ = real(f1())
_ = real(f2()) // ERROR too many arguments
}
func recover1() {
_ = recover()
_ = recover(10) // ERROR too many arguments
recover()
var s []int
recover(s... /* ERROR invalid use of \.\.\. */ )
}
func recover2() {
f1 := func() (x int) { return }
f2 := func() (x, y int) { return }
_ = recover(f0 /* ERROR used as value */ ())
_ = recover(f1()) // ERROR too many arguments
_ = recover(f2()) // ERROR too many arguments
}
// assuming types.DefaultPtrSize == 8
type S0 struct{ // offset
a bool // 0
b rune // 4
c *int // 8
d bool // 16
e complex128 // 24
} // 40
type S1 struct{ // offset
x float32 // 0
y string // 8
z *S1 // 24
S0 // 32
} // 72
type S2 struct{ // offset
*S1 // 0
} // 8
type S3 struct { // offset
a int64 // 0
b int32 // 8
} // 12
type S4 struct { // offset
S3 // 0
int32 // 12
} // 16
type S5 struct { // offset
a [3]int32 // 0
b int32 // 12
} // 16
func (S2) m() {}
func Alignof1() {
var x int
_ = unsafe.Alignof() // ERROR not enough arguments
_ = unsafe.Alignof(1, 2) // ERROR too many arguments
_ = unsafe.Alignof(int /* ERROR not an expression */)
_ = unsafe.Alignof(42)
_ = unsafe.Alignof(new(struct{}))
_ = unsafe.Alignof(1<<10)
_ = unsafe.Alignof(1 /* ERROR overflows */ <<1000)
_ = unsafe.Alignof(nil /* ERROR "untyped nil */ )
unsafe /* ERROR not used */ .Alignof(x)
var y S0
assert(unsafe.Alignof(y.a) == 1)
assert(unsafe.Alignof(y.b) == 4)
assert(unsafe.Alignof(y.c) == 8)
assert(unsafe.Alignof(y.d) == 1)
assert(unsafe.Alignof(y.e) == 8)
var s []byte
_ = unsafe.Alignof(s)
_ = unsafe.Alignof(s... /* ERROR invalid use of \.\.\. */ )
}
func Alignof2() {
f1 := func() (x int32) { return }
f2 := func() (x, y int32) { return }
_ = unsafe.Alignof(f0 /* ERROR used as value */ ())
assert(unsafe.Alignof(f1()) == 4)
_ = unsafe.Alignof(f2()) // ERROR too many arguments
}
func Offsetof1() {
var x struct{ f int }
_ = unsafe.Offsetof() // ERROR not enough arguments
_ = unsafe.Offsetof(1, 2) // ERROR too many arguments
_ = unsafe.Offsetof(int /* ERROR not a selector expression */ )
_ = unsafe.Offsetof(x /* ERROR not a selector expression */ )
_ = unsafe.Offsetof(nil /* ERROR not a selector expression */ )
_ = unsafe.Offsetof(x.f)
_ = unsafe.Offsetof((x.f))
_ = unsafe.Offsetof((((((((x))).f)))))
unsafe /* ERROR not used */ .Offsetof(x.f)
var y0 S0
assert(unsafe.Offsetof(y0.a) == 0)
assert(unsafe.Offsetof(y0.b) == 4)
assert(unsafe.Offsetof(y0.c) == 8)
assert(unsafe.Offsetof(y0.d) == 16)
assert(unsafe.Offsetof(y0.e) == 24)
var y1 S1
assert(unsafe.Offsetof(y1.x) == 0)
assert(unsafe.Offsetof(y1.y) == 8)
assert(unsafe.Offsetof(y1.z) == 24)
assert(unsafe.Offsetof(y1.S0) == 32)
assert(unsafe.Offsetof(y1.S0.a) == 0) // relative to S0
assert(unsafe.Offsetof(y1.a) == 32) // relative to S1
assert(unsafe.Offsetof(y1.b) == 36) // relative to S1
assert(unsafe.Offsetof(y1.c) == 40) // relative to S1
assert(unsafe.Offsetof(y1.d) == 48) // relative to S1
assert(unsafe.Offsetof(y1.e) == 56) // relative to S1
var y1p *S1
assert(unsafe.Offsetof(y1p.S0) == 32)
type P *S1
var p P = y1p
assert(unsafe.Offsetof(p.S0) == 32)
var y2 S2
assert(unsafe.Offsetof(y2.S1) == 0)
_ = unsafe.Offsetof(y2 /* ERROR embedded via a pointer */ .x)
_ = unsafe.Offsetof(y2 /* ERROR method value */ .m)
var s []byte
_ = unsafe.Offsetof(s... /* ERROR invalid use of \.\.\. */ )
}
func Offsetof2() {
f1 := func() (x int32) { return }
f2 := func() (x, y int32) { return }
_ = unsafe.Offsetof(f0 /* ERROR not a selector expression */ ())
_ = unsafe.Offsetof(f1 /* ERROR not a selector expression */ ())
_ = unsafe.Offsetof(f2 /* ERROR not a selector expression */ ())
}
func Sizeof1() {
var x int
_ = unsafe.Sizeof() // ERROR not enough arguments
_ = unsafe.Sizeof(1, 2) // ERROR too many arguments
_ = unsafe.Sizeof(int /* ERROR not an expression */)
_ = unsafe.Sizeof(42)
_ = unsafe.Sizeof(new(complex128))
_ = unsafe.Sizeof(1<<10)
_ = unsafe.Sizeof(1 /* ERROR overflows */ <<1000)
_ = unsafe.Sizeof(nil /* ERROR untyped nil */ )
unsafe /* ERROR not used */ .Sizeof(x)
// basic types have size guarantees
assert(unsafe.Sizeof(byte(0)) == 1)
assert(unsafe.Sizeof(uint8(0)) == 1)
assert(unsafe.Sizeof(int8(0)) == 1)
assert(unsafe.Sizeof(uint16(0)) == 2)
assert(unsafe.Sizeof(int16(0)) == 2)
assert(unsafe.Sizeof(uint32(0)) == 4)
assert(unsafe.Sizeof(int32(0)) == 4)
assert(unsafe.Sizeof(float32(0)) == 4)
assert(unsafe.Sizeof(uint64(0)) == 8)
assert(unsafe.Sizeof(int64(0)) == 8)
assert(unsafe.Sizeof(float64(0)) == 8)
assert(unsafe.Sizeof(complex64(0)) == 8)
assert(unsafe.Sizeof(complex128(0)) == 16)
var y0 S0
assert(unsafe.Sizeof(y0.a) == 1)
assert(unsafe.Sizeof(y0.b) == 4)
assert(unsafe.Sizeof(y0.c) == 8)
assert(unsafe.Sizeof(y0.d) == 1)
assert(unsafe.Sizeof(y0.e) == 16)
assert(unsafe.Sizeof(y0) == 40)
var y1 S1
assert(unsafe.Sizeof(y1) == 72)
var y2 S2
assert(unsafe.Sizeof(y2) == 8)
var y3 S3
assert(unsafe.Sizeof(y3) == 12)
var y4 S4
assert(unsafe.Sizeof(y4) == 16)
var y5 S5
assert(unsafe.Sizeof(y5) == 16)
var a3 [10]S3
assert(unsafe.Sizeof(a3) == 156)
// test case for issue 5670
type T struct {
a int32
_ int32
c int32
}
assert(unsafe.Sizeof(T{}) == 12)
var s []byte
_ = unsafe.Sizeof(s)
_ = unsafe.Sizeof(s... /* ERROR invalid use of \.\.\. */ )
}
func Sizeof2() {
f1 := func() (x int64) { return }
f2 := func() (x, y int64) { return }
_ = unsafe.Sizeof(f0 /* ERROR used as value */ ())
assert(unsafe.Sizeof(f1()) == 8)
_ = unsafe.Sizeof(f2()) // ERROR too many arguments
}
// self-testing only
func assert1() {
var x int
assert() /* ERROR not enough arguments */
assert(1, 2) /* ERROR too many arguments */
assert("foo" /* ERROR boolean constant */ )
assert(x /* ERROR boolean constant */)
assert(true)
assert /* ERROR failed */ (false)
_ = assert(true)
var s []byte
assert(s... /* ERROR invalid use of \.\.\. */ )
}
func assert2() {
f1 := func() (x bool) { return }
f2 := func() (x bool) { return }
assert(f0 /* ERROR used as value */ ())
assert(f1 /* ERROR boolean constant */ ())
assert(f2 /* ERROR boolean constant */ ())
}
// self-testing only
func trace1() {
// Uncomment the code below to test trace - will produce console output
// _ = trace /* ERROR no value */ ()
// _ = trace(1)
// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
var s []byte
trace(s... /* ERROR invalid use of \.\.\. */ )
}
func trace2() {
f1 := func() (x int) { return }
f2 := func() (x int, y string) { return }
f3 := func() (x int, y string, z []int) { return }
_ = f1
_ = f2
_ = f3
// Uncomment the code below to test trace - will produce console output
// trace(f0())
// trace(f1())
// trace(f2())
// trace(f3())
// trace(f0(), 1)
// trace(f1(), 1, 2)
// trace(f2(), 1, 2, 3)
// trace(f3(), 1, 2, 3, 4)
}

350
src/cmd/compile/internal/types2/testdata/const0.src vendored Normal file
View file

@ -0,0 +1,350 @@
// 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.
// constant declarations
package const0
import "unsafe"
// constants declarations must be initialized by constants
var x = 0
const c0 = x /* ERROR "not constant" */
// typed constants must have constant types
const _ interface /* ERROR invalid constant type */ {} = 0
func _ () {
const _ interface /* ERROR invalid constant type */ {} = 0
for i := 0; i < 10; i++ {} // don't crash with non-nil iota here
}
// untyped constants
const (
// boolean values
ub0 = false
ub1 = true
ub2 = 2 < 1
ub3 = ui1 == uf1
ub4 = true /* ERROR "cannot convert" */ == 0
// integer values
ui0 = 0
ui1 = 1
ui2 = 42
ui3 = 3141592653589793238462643383279502884197169399375105820974944592307816406286
ui4 = -10
ui5 = ui0 + ui1
ui6 = ui1 - ui1
ui7 = ui2 * ui1
ui8 = ui3 / ui3
ui9 = ui3 % ui3
ui10 = 1 / 0 /* ERROR "division by zero" */
ui11 = ui1 / 0 /* ERROR "division by zero" */
ui12 = ui3 / ui0 /* ERROR "division by zero" */
ui13 = 1 % 0 /* ERROR "division by zero" */
ui14 = ui1 % 0 /* ERROR "division by zero" */
ui15 = ui3 % ui0 /* ERROR "division by zero" */
ui16 = ui2 & ui3
ui17 = ui2 | ui3
ui18 = ui2 ^ ui3
ui19 = 1 /* ERROR "invalid operation" */ % 1.0
// floating point values
uf0 = 0.
uf1 = 1.
uf2 = 4.2e1
uf3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
uf4 = 1e-1
uf5 = uf0 + uf1
uf6 = uf1 - uf1
uf7 = uf2 * uf1
uf8 = uf3 / uf3
uf9 = uf3 /* ERROR "not defined" */ % uf3
uf10 = 1 / 0 /* ERROR "division by zero" */
uf11 = uf1 / 0 /* ERROR "division by zero" */
uf12 = uf3 / uf0 /* ERROR "division by zero" */
uf16 = uf2 /* ERROR "not defined" */ & uf3
uf17 = uf2 /* ERROR "not defined" */ | uf3
uf18 = uf2 /* ERROR "not defined" */ ^ uf3
// complex values
uc0 = 0.i
uc1 = 1.i
uc2 = 4.2e1i
uc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
uc4 = 1e-1i
uc5 = uc0 + uc1
uc6 = uc1 - uc1
uc7 = uc2 * uc1
uc8 = uc3 / uc3
uc9 = uc3 /* ERROR "not defined" */ % uc3
uc10 = 1 / 0 /* ERROR "division by zero" */
uc11 = uc1 / 0 /* ERROR "division by zero" */
uc12 = uc3 / uc0 /* ERROR "division by zero" */
uc16 = uc2 /* ERROR "not defined" */ & uc3
uc17 = uc2 /* ERROR "not defined" */ | uc3
uc18 = uc2 /* ERROR "not defined" */ ^ uc3
)
type (
mybool bool
myint int
myfloat float64
mycomplex complex128
)
// typed constants
const (
// boolean values
tb0 bool = false
tb1 bool = true
tb2 mybool = 2 < 1
tb3 mybool = ti1 /* ERROR "mismatched types" */ == tf1
// integer values
ti0 int8 = ui0
ti1 int32 = ui1
ti2 int64 = ui2
ti3 myint = ui3 /* ERROR "overflows" */
ti4 myint = ui4
ti5 = ti0 /* ERROR "mismatched types" */ + ti1
ti6 = ti1 - ti1
ti7 = ti2 /* ERROR "mismatched types" */ * ti1
ti8 = ti3 / ti3
ti9 = ti3 % ti3
ti10 = 1 / 0 /* ERROR "division by zero" */
ti11 = ti1 / 0 /* ERROR "division by zero" */
ti12 = ti3 /* ERROR "mismatched types" */ / ti0
ti13 = 1 % 0 /* ERROR "division by zero" */
ti14 = ti1 % 0 /* ERROR "division by zero" */
ti15 = ti3 /* ERROR "mismatched types" */ % ti0
ti16 = ti2 /* ERROR "mismatched types" */ & ti3
ti17 = ti2 /* ERROR "mismatched types" */ | ti4
ti18 = ti2 ^ ti5 // no mismatched types error because the type of ti5 is unknown
// floating point values
tf0 float32 = 0.
tf1 float32 = 1.
tf2 float64 = 4.2e1
tf3 myfloat = 3.141592653589793238462643383279502884197169399375105820974944592307816406286
tf4 myfloat = 1e-1
tf5 = tf0 + tf1
tf6 = tf1 - tf1
tf7 = tf2 /* ERROR "mismatched types" */ * tf1
tf8 = tf3 / tf3
tf9 = tf3 /* ERROR "not defined" */ % tf3
tf10 = 1 / 0 /* ERROR "division by zero" */
tf11 = tf1 / 0 /* ERROR "division by zero" */
tf12 = tf3 /* ERROR "mismatched types" */ / tf0
tf16 = tf2 /* ERROR "mismatched types" */ & tf3
tf17 = tf2 /* ERROR "mismatched types" */ | tf3
tf18 = tf2 /* ERROR "mismatched types" */ ^ tf3
// complex values
tc0 = 0.i
tc1 = 1.i
tc2 = 4.2e1i
tc3 = 3.141592653589793238462643383279502884197169399375105820974944592307816406286i
tc4 = 1e-1i
tc5 = tc0 + tc1
tc6 = tc1 - tc1
tc7 = tc2 * tc1
tc8 = tc3 / tc3
tc9 = tc3 /* ERROR "not defined" */ % tc3
tc10 = 1 / 0 /* ERROR "division by zero" */
tc11 = tc1 / 0 /* ERROR "division by zero" */
tc12 = tc3 / tc0 /* ERROR "division by zero" */
tc16 = tc2 /* ERROR "not defined" */ & tc3
tc17 = tc2 /* ERROR "not defined" */ | tc3
tc18 = tc2 /* ERROR "not defined" */ ^ tc3
)
// initialization cycles
const (
a /* ERROR "initialization cycle" */ = a
b /* ERROR "initialization cycle" */ , c /* ERROR "initialization cycle" */, d, e = e, d, c, b // TODO(gri) should only have one cycle error
f float64 = d
)
// multiple initialization
const (
a1, a2, a3 = 7, 3.1415926, "foo"
b1, b2, b3 = b3, b1, 42
c1, c2, c3 /* ERROR "missing init expr for c3" */ = 1, 2
d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
_p0 = assert(a1 == 7)
_p1 = assert(a2 == 3.1415926)
_p2 = assert(a3 == "foo")
_p3 = assert(b1 == 42)
_p4 = assert(b2 == 42)
_p5 = assert(b3 == 42)
)
func _() {
const (
a1, a2, a3 = 7, 3.1415926, "foo"
b1, b2, b3 = b3, b1, 42
c1, c2, c3 /* ERROR "missing init expr for c3" */ = 1, 2
d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
_p0 = assert(a1 == 7)
_p1 = assert(a2 == 3.1415926)
_p2 = assert(a3 == "foo")
_p3 = assert(b1 == 42)
_p4 = assert(b2 == 42)
_p5 = assert(b3 == 42)
)
}
// iota
const (
iota0 = iota
iota1 = iota
iota2 = iota*2
_a0 = assert(iota0 == 0)
_a1 = assert(iota1 == 1)
_a2 = assert(iota2 == 4)
iota6 = iota*3
iota7
iota8
_a3 = assert(iota7 == 21)
_a4 = assert(iota8 == 24)
)
const (
_b0 = iota
_b1 = assert(iota + iota2 == 5)
_b2 = len([iota]int{}) // iota may appear in a type!
_b3 = assert(_b2 == 2)
_b4 = len(A{})
)
type A [iota /* ERROR "cannot use iota" */ ]int
// constant expressions with operands across different
// constant declarations must use the right iota values
const (
_c0 = iota
_c1
_c2
_x = _c2 + _d1 + _e0 // 3
)
const (
_d0 = iota
_d1
)
const (
_e0 = iota
)
var _ = assert(_x == 3)
// special cases
const (
_n0 = nil /* ERROR "not constant" */
_n1 = [ /* ERROR "not constant" */ ]int{}
)
// iotas must not be usable in expressions outside constant declarations
type _ [iota /* ERROR "iota outside constant decl" */ ]byte
var _ = iota /* ERROR "iota outside constant decl" */
func _() {
_ = iota /* ERROR "iota outside constant decl" */
const _ = iota
_ = iota /* ERROR "iota outside constant decl" */
}
func _() {
iota := 123
const x = iota /* ERROR "is not constant" */
var y = iota
_ = y
}
// iotas are usable inside closures in constant declarations (#22345)
const (
_ = iota
_ = len([iota]byte{})
_ = unsafe.Sizeof(iota)
_ = unsafe.Sizeof(func() { _ = iota })
_ = unsafe.Sizeof(func() { var _ = iota })
_ = unsafe.Sizeof(func() { const _ = iota })
_ = unsafe.Sizeof(func() { type _ [iota]byte })
_ = unsafe.Sizeof(func() { func() int { return iota }() })
)
// verify inner and outer const declarations have distinct iotas
const (
zero = iota
one = iota
_ = unsafe.Sizeof(func() {
var x [iota]int // [2]int
const (
Zero = iota
One
Two
_ = unsafe.Sizeof([iota-1]int{} == x) // assert types are equal
_ = unsafe.Sizeof([Two]int{} == x) // assert types are equal
)
var z [iota]int // [2]int
_ = unsafe.Sizeof([2]int{} == z) // assert types are equal
})
three = iota // the sequence continues
)
var _ [three]int = [3]int{} // assert 'three' has correct value
var (
_ = iota /* ERROR "iota outside constant decl" */
_ = unsafe.Sizeof(iota /* ERROR "iota outside constant decl" */ )
_ = unsafe.Sizeof(func() { _ = iota /* ERROR "iota outside constant decl" */ })
_ = unsafe.Sizeof(func() { var _ = iota /* ERROR "iota outside constant decl" */ })
_ = unsafe.Sizeof(func() { type _ [iota /* ERROR "iota outside constant decl" */ ]byte })
_ = unsafe.Sizeof(func() { func() int { return iota /* ERROR "iota outside constant decl" */ }() })
)
// constant arithmetic precision and rounding must lead to expected (integer) results
var _ = []int64{
0.0005 * 1e9,
0.001 * 1e9,
0.005 * 1e9,
0.01 * 1e9,
0.05 * 1e9,
0.1 * 1e9,
0.5 * 1e9,
1 * 1e9,
5 * 1e9,
}
const _ = unsafe.Sizeof(func() {
const _ = 0
_ = iota
const (
zero = iota
one
)
assert(one == 1)
assert(iota == 0)
})

322
src/cmd/compile/internal/types2/testdata/const1.src vendored Normal file
View file

@ -0,0 +1,322 @@
// 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.
// constant conversions
package const1
const(
mi = ^int(0)
mu = ^uint(0)
mp = ^uintptr(0)
logSizeofInt = uint(mi>>8&1 + mi>>16&1 + mi>>32&1)
logSizeofUint = uint(mu>>8&1 + mu>>16&1 + mu>>32&1)
logSizeofUintptr = uint(mp>>8&1 + mp>>16&1 + mp>>32&1)
)
const (
minInt8 = -1<<(8<<iota - 1)
minInt16
minInt32
minInt64
minInt = -1<<(8<<logSizeofInt - 1)
)
const (
maxInt8 = 1<<(8<<iota - 1) - 1
maxInt16
maxInt32
maxInt64
maxInt = 1<<(8<<logSizeofInt - 1) - 1
)
const (
maxUint8 = 1<<(8<<iota) - 1
maxUint16
maxUint32
maxUint64
maxUint = 1<<(8<<logSizeofUint) - 1
maxUintptr = 1<<(8<<logSizeofUintptr) - 1
)
const (
smallestFloat32 = 1.0 / (1<<(127 - 1 + 23))
smallestFloat64 = 1.0 / (1<<(1023 - 1 + 52))
)
const (
_ = assert(smallestFloat32 > 0)
_ = assert(smallestFloat64 > 0)
)
const (
maxFloat32 = 1<<127 * (1<<24 - 1) / (1.0<<23)
maxFloat64 = 1<<1023 * (1<<53 - 1) / (1.0<<52)
)
const (
_ int8 = minInt8 /* ERROR "overflows" */ - 1
_ int8 = minInt8
_ int8 = maxInt8
_ int8 = maxInt8 /* ERROR "overflows" */ + 1
_ int8 = smallestFloat64 /* ERROR "truncated" */
_ = int8(minInt8 /* ERROR "cannot convert" */ - 1)
_ = int8(minInt8)
_ = int8(maxInt8)
_ = int8(maxInt8 /* ERROR "cannot convert" */ + 1)
_ = int8(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ int16 = minInt16 /* ERROR "overflows" */ - 1
_ int16 = minInt16
_ int16 = maxInt16
_ int16 = maxInt16 /* ERROR "overflows" */ + 1
_ int16 = smallestFloat64 /* ERROR "truncated" */
_ = int16(minInt16 /* ERROR "cannot convert" */ - 1)
_ = int16(minInt16)
_ = int16(maxInt16)
_ = int16(maxInt16 /* ERROR "cannot convert" */ + 1)
_ = int16(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ int32 = minInt32 /* ERROR "overflows" */ - 1
_ int32 = minInt32
_ int32 = maxInt32
_ int32 = maxInt32 /* ERROR "overflows" */ + 1
_ int32 = smallestFloat64 /* ERROR "truncated" */
_ = int32(minInt32 /* ERROR "cannot convert" */ - 1)
_ = int32(minInt32)
_ = int32(maxInt32)
_ = int32(maxInt32 /* ERROR "cannot convert" */ + 1)
_ = int32(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ int64 = minInt64 /* ERROR "overflows" */ - 1
_ int64 = minInt64
_ int64 = maxInt64
_ int64 = maxInt64 /* ERROR "overflows" */ + 1
_ int64 = smallestFloat64 /* ERROR "truncated" */
_ = int64(minInt64 /* ERROR "cannot convert" */ - 1)
_ = int64(minInt64)
_ = int64(maxInt64)
_ = int64(maxInt64 /* ERROR "cannot convert" */ + 1)
_ = int64(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ int = minInt /* ERROR "overflows" */ - 1
_ int = minInt
_ int = maxInt
_ int = maxInt /* ERROR "overflows" */ + 1
_ int = smallestFloat64 /* ERROR "truncated" */
_ = int(minInt /* ERROR "cannot convert" */ - 1)
_ = int(minInt)
_ = int(maxInt)
_ = int(maxInt /* ERROR "cannot convert" */ + 1)
_ = int(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ uint8 = 0 /* ERROR "overflows" */ - 1
_ uint8 = 0
_ uint8 = maxUint8
_ uint8 = maxUint8 /* ERROR "overflows" */ + 1
_ uint8 = smallestFloat64 /* ERROR "truncated" */
_ = uint8(0 /* ERROR "cannot convert" */ - 1)
_ = uint8(0)
_ = uint8(maxUint8)
_ = uint8(maxUint8 /* ERROR "cannot convert" */ + 1)
_ = uint8(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ uint16 = 0 /* ERROR "overflows" */ - 1
_ uint16 = 0
_ uint16 = maxUint16
_ uint16 = maxUint16 /* ERROR "overflows" */ + 1
_ uint16 = smallestFloat64 /* ERROR "truncated" */
_ = uint16(0 /* ERROR "cannot convert" */ - 1)
_ = uint16(0)
_ = uint16(maxUint16)
_ = uint16(maxUint16 /* ERROR "cannot convert" */ + 1)
_ = uint16(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ uint32 = 0 /* ERROR "overflows" */ - 1
_ uint32 = 0
_ uint32 = maxUint32
_ uint32 = maxUint32 /* ERROR "overflows" */ + 1
_ uint32 = smallestFloat64 /* ERROR "truncated" */
_ = uint32(0 /* ERROR "cannot convert" */ - 1)
_ = uint32(0)
_ = uint32(maxUint32)
_ = uint32(maxUint32 /* ERROR "cannot convert" */ + 1)
_ = uint32(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ uint64 = 0 /* ERROR "overflows" */ - 1
_ uint64 = 0
_ uint64 = maxUint64
_ uint64 = maxUint64 /* ERROR "overflows" */ + 1
_ uint64 = smallestFloat64 /* ERROR "truncated" */
_ = uint64(0 /* ERROR "cannot convert" */ - 1)
_ = uint64(0)
_ = uint64(maxUint64)
_ = uint64(maxUint64 /* ERROR "cannot convert" */ + 1)
_ = uint64(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ uint = 0 /* ERROR "overflows" */ - 1
_ uint = 0
_ uint = maxUint
_ uint = maxUint /* ERROR "overflows" */ + 1
_ uint = smallestFloat64 /* ERROR "truncated" */
_ = uint(0 /* ERROR "cannot convert" */ - 1)
_ = uint(0)
_ = uint(maxUint)
_ = uint(maxUint /* ERROR "cannot convert" */ + 1)
_ = uint(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ uintptr = 0 /* ERROR "overflows" */ - 1
_ uintptr = 0
_ uintptr = maxUintptr
_ uintptr = maxUintptr /* ERROR "overflows" */ + 1
_ uintptr = smallestFloat64 /* ERROR "truncated" */
_ = uintptr(0 /* ERROR "cannot convert" */ - 1)
_ = uintptr(0)
_ = uintptr(maxUintptr)
_ = uintptr(maxUintptr /* ERROR "cannot convert" */ + 1)
_ = uintptr(smallestFloat64 /* ERROR "cannot convert" */)
)
const (
_ float32 = minInt64
_ float64 = minInt64
_ complex64 = minInt64
_ complex128 = minInt64
_ = float32(minInt64)
_ = float64(minInt64)
_ = complex64(minInt64)
_ = complex128(minInt64)
)
const (
_ float32 = maxUint64
_ float64 = maxUint64
_ complex64 = maxUint64
_ complex128 = maxUint64
_ = float32(maxUint64)
_ = float64(maxUint64)
_ = complex64(maxUint64)
_ = complex128(maxUint64)
)
// TODO(gri) find smaller deltas below
const delta32 = maxFloat32/(1 << 23)
const (
_ float32 = - /* ERROR "overflow" */ (maxFloat32 + delta32)
_ float32 = -maxFloat32
_ float32 = maxFloat32
_ float32 = maxFloat32 /* ERROR "overflow" */ + delta32
_ = float32(- /* ERROR "cannot convert" */ (maxFloat32 + delta32))
_ = float32(-maxFloat32)
_ = float32(maxFloat32)
_ = float32(maxFloat32 /* ERROR "cannot convert" */ + delta32)
_ = assert(float32(smallestFloat32) == smallestFloat32)
_ = assert(float32(smallestFloat32/2) == 0)
_ = assert(float32(smallestFloat64) == 0)
_ = assert(float32(smallestFloat64/2) == 0)
)
const delta64 = maxFloat64/(1 << 52)
const (
_ float64 = - /* ERROR "overflow" */ (maxFloat64 + delta64)
_ float64 = -maxFloat64
_ float64 = maxFloat64
_ float64 = maxFloat64 /* ERROR "overflow" */ + delta64
_ = float64(- /* ERROR "cannot convert" */ (maxFloat64 + delta64))
_ = float64(-maxFloat64)
_ = float64(maxFloat64)
_ = float64(maxFloat64 /* ERROR "cannot convert" */ + delta64)
_ = assert(float64(smallestFloat32) == smallestFloat32)
_ = assert(float64(smallestFloat32/2) == smallestFloat32/2)
_ = assert(float64(smallestFloat64) == smallestFloat64)
_ = assert(float64(smallestFloat64/2) == 0)
)
const (
_ complex64 = - /* ERROR "overflow" */ (maxFloat32 + delta32)
_ complex64 = -maxFloat32
_ complex64 = maxFloat32
_ complex64 = maxFloat32 /* ERROR "overflow" */ + delta32
_ = complex64(- /* ERROR "cannot convert" */ (maxFloat32 + delta32))
_ = complex64(-maxFloat32)
_ = complex64(maxFloat32)
_ = complex64(maxFloat32 /* ERROR "cannot convert" */ + delta32)
)
const (
_ complex128 = - /* ERROR "overflow" */ (maxFloat64 + delta64)
_ complex128 = -maxFloat64
_ complex128 = maxFloat64
_ complex128 = maxFloat64 /* ERROR "overflow" */ + delta64
_ = complex128(- /* ERROR "cannot convert" */ (maxFloat64 + delta64))
_ = complex128(-maxFloat64)
_ = complex128(maxFloat64)
_ = complex128(maxFloat64 /* ERROR "cannot convert" */ + delta64)
)
// Initialization of typed constant and conversion are the same:
const (
f32 = 1 + smallestFloat32
x32 float32 = f32
y32 = float32(f32)
_ = assert(x32 - y32 == 0)
)
const (
f64 = 1 + smallestFloat64
x64 float64 = f64
y64 = float64(f64)
_ = assert(x64 - y64 == 0)
)
const (
_ = int8(-1) << 7
_ = int8 /* ERROR "overflows" */ (-1) << 8
_ = uint32(1) << 31
_ = uint32 /* ERROR "overflows" */ (1) << 32
)

110
src/cmd/compile/internal/types2/testdata/constdecl.src vendored Normal file
View file

@ -0,0 +1,110 @@
// 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 constdecl
import "math"
import "unsafe"
var v int
// Const decls must be initialized by constants.
const _ = v /* ERROR "not constant" */
const _ = math /* ERROR "not constant" */ .Sin(0)
const _ = int /* ERROR "not an expression" */
func _() {
const _ = v /* ERROR "not constant" */
const _ = math /* ERROR "not constant" */ .Sin(0)
const _ = int /* ERROR "not an expression" */
}
// Identifier and expression arity must match.
// The first error message is produced by the parser.
// In a real-world scenario, the type-checker would not be run
// in this case and the 2nd error message would not appear.
const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
const _ = 1, 2 /* ERROR "extra init expr 2" */
const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
const _ int = 1, 2 /* ERROR "extra init expr 2" */
const (
_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
_ = 1, 2 /* ERROR "extra init expr 2" */
_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
_ int = 1, 2 /* ERROR "extra init expr 2" */
)
const (
_ = 1
_
_, _ /* ERROR "missing init expr for _" */
_
)
const (
_, _ = 1, 2
_, _
_ /* ERROR "extra init expr at" */
_, _
_, _, _ /* ERROR "missing init expr for _" */
_, _
)
func _() {
const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
const _ = 1, 2 /* ERROR "extra init expr 2" */
const _ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
const _ int = 1, 2 /* ERROR "extra init expr 2" */
const (
_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */
_ = 1, 2 /* ERROR "extra init expr 2" */
_ /* ERROR "missing constant value" */ /* ERROR "missing init expr for _" */ int
_ int = 1, 2 /* ERROR "extra init expr 2" */
)
const (
_ = 1
_
_, _ /* ERROR "missing init expr for _" */
_
)
const (
_, _ = 1, 2
_, _
_ /* ERROR "extra init expr at" */
_, _
_, _, _ /* ERROR "missing init expr for _" */
_, _
)
}
// Test case for constant with invalid initialization.
// Caused panic because the constant value was not set up (gri - 7/8/2014).
func _() {
const (
x string = missing /* ERROR "undeclared name" */
y = x + ""
)
}
// Test case for constants depending on function literals (see also #22992).
const A /* ERROR initialization cycle */ = unsafe.Sizeof(func() { _ = A })
func _() {
// The function literal below must not see a.
const a = unsafe.Sizeof(func() { _ = a /* ERROR "undeclared name" */ })
const b = unsafe.Sizeof(func() { _ = a })
// The function literal below must not see x, y, or z.
const x, y, z = 0, 1, unsafe.Sizeof(func() { _ = x /* ERROR "undeclared name" */ + y /* ERROR "undeclared name" */ + z /* ERROR "undeclared name" */ })
}
// TODO(gri) move extra tests from testdata/const0.src into here

93
src/cmd/compile/internal/types2/testdata/conversions.src vendored Normal file
View file

@ -0,0 +1,93 @@
// 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.
// conversions
package conversions
import "unsafe"
// argument count
var (
_ = int() /* ERROR "missing argument" */
_ = int(1, 2 /* ERROR "too many arguments" */ )
)
// numeric constant conversions are in const1.src.
func string_conversions() {
const A = string(65)
assert(A == "A")
const E = string(-1)
assert(E == "\uFFFD")
assert(E == string(1234567890))
type myint int
assert(A == string(myint(65)))
type mystring string
const _ mystring = mystring("foo")
const _ = string(true /* ERROR "cannot convert" */ )
const _ = string(1.2 /* ERROR "cannot convert" */ )
const _ = string(nil /* ERROR "cannot convert" */ )
// issues 11357, 11353: argument must be of integer type
_ = string(0.0 /* ERROR "cannot convert" */ )
_ = string(0i /* ERROR "cannot convert" */ )
_ = string(1 /* ERROR "cannot convert" */ + 2i)
}
func interface_conversions() {
type E interface{}
type I1 interface{
m1()
}
type I2 interface{
m1()
m2(x int)
}
type I3 interface{
m1()
m2() int
}
var e E
var i1 I1
var i2 I2
var i3 I3
_ = E(0)
_ = E(nil)
_ = E(e)
_ = E(i1)
_ = E(i2)
_ = I1(0 /* ERROR "cannot convert" */ )
_ = I1(nil)
_ = I1(i1)
_ = I1(e /* ERROR "cannot convert" */ )
_ = I1(i2)
_ = I2(nil)
_ = I2(i1 /* ERROR "cannot convert" */ )
_ = I2(i2)
_ = I2(i3 /* ERROR "cannot convert" */ )
_ = I3(nil)
_ = I3(i1 /* ERROR "cannot convert" */ )
_ = I3(i2 /* ERROR "cannot convert" */ )
_ = I3(i3)
// TODO(gri) add more tests, improve error message
}
func issue6326() {
type T unsafe.Pointer
var x T
_ = uintptr(x) // see issue 6326
}

313
src/cmd/compile/internal/types2/testdata/conversions2.src vendored Normal file
View file

@ -0,0 +1,313 @@
// Copyright 2016 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 various valid and invalid struct assignments and conversions.
// Does not compile.
package conversions2
type I interface {
m()
}
// conversions between structs
func _() {
type S struct{}
type T struct{}
var s S
var t T
var u struct{}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u
s = S(s)
s = S(t)
s = S(u)
t = u
t = T(u)
}
func _() {
type S struct{ x int }
type T struct {
x int "foo"
}
var s S
var t T
var u struct {
x int "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = S(s)
s = S(t)
s = S(u)
t = u // ERROR "cannot use .* in assignment"
t = T(u)
}
func _() {
type E struct{ x int }
type S struct{ x E }
type T struct {
x E "foo"
}
var s S
var t T
var u struct {
x E "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = S(s)
s = S(t)
s = S(u)
t = u // ERROR "cannot use .* in assignment"
t = T(u)
}
func _() {
type S struct {
x struct {
x int "foo"
}
}
type T struct {
x struct {
x int "bar"
} "foo"
}
var s S
var t T
var u struct {
x struct {
x int "bar"
} "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = S(s)
s = S(t)
s = S(u)
t = u // ERROR "cannot use .* in assignment"
t = T(u)
}
func _() {
type E1 struct {
x int "foo"
}
type E2 struct {
x int "bar"
}
type S struct{ x E1 }
type T struct {
x E2 "foo"
}
var s S
var t T
var u struct {
x E2 "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = S(s)
s = S(t /* ERROR "cannot convert" */ )
s = S(u /* ERROR "cannot convert" */ )
t = u // ERROR "cannot use .* in assignment"
t = T(u)
}
func _() {
type E struct{ x int }
type S struct {
f func(struct {
x int "foo"
})
}
type T struct {
f func(struct {
x int "bar"
})
}
var s S
var t T
var u struct{ f func(E) }
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = S(s)
s = S(t)
s = S(u /* ERROR "cannot convert" */ )
t = u // ERROR "cannot use .* in assignment"
t = T(u /* ERROR "cannot convert" */ )
}
// conversions between pointers to structs
func _() {
type S struct{}
type T struct{}
var s *S
var t *T
var u *struct{}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t)
s = (*S)(u)
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u)
}
func _() {
type S struct{ x int }
type T struct {
x int "foo"
}
var s *S
var t *T
var u *struct {
x int "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t)
s = (*S)(u)
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u)
}
func _() {
type E struct{ x int }
type S struct{ x E }
type T struct {
x E "foo"
}
var s *S
var t *T
var u *struct {
x E "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t)
s = (*S)(u)
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u)
}
func _() {
type S struct {
x struct {
x int "foo"
}
}
type T struct {
x struct {
x int "bar"
} "foo"
}
var s *S
var t *T
var u *struct {
x struct {
x int "bar"
} "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t)
s = (*S)(u)
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u)
}
func _() {
type E1 struct {
x int "foo"
}
type E2 struct {
x int "bar"
}
type S struct{ x E1 }
type T struct {
x E2 "foo"
}
var s *S
var t *T
var u *struct {
x E2 "bar"
}
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t /* ERROR "cannot convert" */ )
s = (*S)(u /* ERROR "cannot convert" */ )
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u)
}
func _() {
type E struct{ x int }
type S struct {
f func(struct {
x int "foo"
})
}
type T struct {
f func(struct {
x int "bar"
})
}
var s *S
var t *T
var u *struct{ f func(E) }
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t)
s = (*S)(u /* ERROR "cannot convert" */ )
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u /* ERROR "cannot convert" */ )
}
func _() {
type E struct{ x int }
type S struct {
f func(*struct {
x int "foo"
})
}
type T struct {
f func(*struct {
x int "bar"
})
}
var s *S
var t *T
var u *struct{ f func(E) }
s = s
s = t // ERROR "cannot use .* in assignment"
s = u // ERROR "cannot use .* in assignment"
s = (*S)(s)
s = (*S)(t)
s = (*S)(u /* ERROR "cannot convert" */ )
t = u // ERROR "cannot use .* in assignment"
t = (*T)(u /* ERROR "cannot convert" */ )
}

174
src/cmd/compile/internal/types2/testdata/cycles.src vendored Normal file
View file

@ -0,0 +1,174 @@
// 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 cycles
import "unsafe"
type (
T0 int
T1 /* ERROR cycle */ T1
T2 *T2
T3 /* ERROR cycle */ T4
T4 T5
T5 T3
T6 T7
T7 *T8
T8 T6
// arrays
A0 /* ERROR cycle */ [10]A0
A1 [10]*A1
A2 /* ERROR cycle */ [10]A3
A3 [10]A4
A4 A2
A5 [10]A6
A6 *A5
// slices
L0 []L0
// structs
S0 /* ERROR cycle */ struct{ _ S0 }
S1 /* ERROR cycle */ struct{ S1 }
S2 struct{ _ *S2 }
S3 struct{ *S3 }
S4 /* ERROR cycle */ struct{ S5 }
S5 struct{ S6 }
S6 S4
// pointers
P0 *P0
// functions
F0 func(F0)
F1 func() F1
F2 func(F2) F2
// interfaces
I0 /* ERROR cycle */ interface{ I0 }
I1 /* ERROR cycle */ interface{ I2 }
I2 interface{ I3 }
I3 interface{ I1 }
I4 interface{ f(I4) }
// testcase for issue 5090
I5 interface{ f(I6) }
I6 interface{ I5 }
// maps
M0 map[M0 /* ERROR invalid map key */ ]M0
// channels
C0 chan C0
)
// test case for issue #34771
type (
AA /* ERROR cycle */ B
B C
C [10]D
D E
E AA
)
func _() {
type (
t1 /* ERROR cycle */ t1
t2 *t2
t3 t4 /* ERROR undeclared */
t4 t5 /* ERROR undeclared */
t5 t3
// arrays
a0 /* ERROR cycle */ [10]a0
a1 [10]*a1
// slices
l0 []l0
// structs
s0 /* ERROR cycle */ struct{ _ s0 }
s1 /* ERROR cycle */ struct{ s1 }
s2 struct{ _ *s2 }
s3 struct{ *s3 }
// pointers
p0 *p0
// functions
f0 func(f0)
f1 func() f1
f2 func(f2) f2
// interfaces
i0 /* ERROR cycle */ interface{ i0 }
// maps
m0 map[m0 /* ERROR invalid map key */ ]m0
// channels
c0 chan c0
)
}
// test cases for issue 6667
type A [10]map[A /* ERROR invalid map key */ ]bool
type S struct {
m map[S /* ERROR invalid map key */ ]bool
}
// test cases for issue 7236
// (cycle detection must not be dependent on starting point of resolution)
type (
P1 *T9
T9 /* ERROR cycle */ T9
T10 /* ERROR cycle */ T10
P2 *T10
)
func (T11) m() {}
type T11 /* ERROR cycle */ struct{ T11 }
type T12 /* ERROR cycle */ struct{ T12 }
func (*T12) m() {}
type (
P3 *T13
T13 /* ERROR cycle */ T13
)
// test cases for issue 18643
// (type cycle detection when non-type expressions are involved)
type (
T14 [len(T14 /* ERROR cycle */ {})]int
T15 [][len(T15 /* ERROR cycle */ {})]int
T16 map[[len(T16 /* ERROR cycle */ {1:2})]int]int
T17 map[int][len(T17 /* ERROR cycle */ {1:2})]int
)
// Test case for types depending on function literals (see also #22992).
type T20 chan [unsafe.Sizeof(func(ch T20){ _ = <-ch })]byte
type T22 = chan [unsafe.Sizeof(func(ch T20){ _ = <-ch })]byte
func _() {
type T0 func(T0)
type T1 /* ERROR cycle */ = func(T1)
type T2 chan [unsafe.Sizeof(func(ch T2){ _ = <-ch })]byte
type T3 /* ERROR cycle */ = chan [unsafe.Sizeof(func(ch T3){ _ = <-ch })]byte
}

77
src/cmd/compile/internal/types2/testdata/cycles1.src vendored Normal file
View file

@ -0,0 +1,77 @@
// 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
type (
A interface {
a() interface {
ABC1
}
}
B interface {
b() interface {
ABC2
}
}
C interface {
c() interface {
ABC3
}
}
AB interface {
A
B
}
BC interface {
B
C
}
ABC1 interface {
A
B
C
}
ABC2 interface {
AB
C
}
ABC3 interface {
A
BC
}
)
var (
x1 ABC1
x2 ABC2
x3 ABC3
)
func _() {
// all types have the same method set
x1 = x2
x2 = x1
x1 = x3
x3 = x1
x2 = x3
x3 = x2
// all methods return the same type again
x1 = x1.a()
x1 = x1.b()
x1 = x1.c()
x2 = x2.a()
x2 = x2.b()
x2 = x2.c()
x3 = x3.a()
x3 = x3.b()
x3 = x3.c()
}

98
src/cmd/compile/internal/types2/testdata/cycles2.src vendored Normal file
View file

@ -0,0 +1,98 @@
// 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"
// Test case for issue 5090
type t interface {
f(u)
}
type u interface {
t
}
func _() {
var t t
var u u
t.f(t)
t.f(u)
u.f(t)
u.f(u)
}
// Test case for issues #6589, #33656.
type A interface {
a() interface {
AB
}
}
type B interface {
b() interface {
AB
}
}
type AB interface {
a() interface {
A
B
}
b() interface {
A
B
}
}
var x AB
var y interface {
A
B
}
var _ = x == y
// Test case for issue 6638.
type T interface {
m() [T(nil).m /* ERROR undefined */ ()[0]]int
}
// Variations of this test case.
type T1 /* ERROR cycle */ interface {
m() [x1.m()[0]]int
}
var x1 T1
type T2 /* ERROR cycle */ interface {
m() [len(x2.m())]int
}
var x2 T2
type T3 /* ERROR cycle */ interface {
m() [unsafe.Sizeof(x3.m)]int
}
var x3 T3
type T4 /* ERROR cycle */ interface {
m() [unsafe.Sizeof(cast4(x4.m))]int // cast is invalid but we have a cycle, so all bets are off
}
var x4 T4
var _ = cast4(x4.m)
type cast4 func()

60
src/cmd/compile/internal/types2/testdata/cycles3.src vendored Normal file
View file

@ -0,0 +1,60 @@
// 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"
var (
_ A = A(nil).a().b().c().d().e().f()
_ A = A(nil).b().c().d().e().f()
_ A = A(nil).c().d().e().f()
_ A = A(nil).d().e().f()
_ A = A(nil).e().f()
_ A = A(nil).f()
_ A = A(nil)
)
type (
A interface {
a() B
B
}
B interface {
b() C
C
}
C interface {
c() D
D
}
D interface {
d() E
E
}
E interface {
e() F
F
}
F interface {
f() A
}
)
type (
U /* ERROR cycle */ interface {
V
}
V interface {
v() [unsafe.Sizeof(u)]int
}
)
var u U

110
src/cmd/compile/internal/types2/testdata/cycles4.src vendored Normal file
View file

@ -0,0 +1,110 @@
// 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
// Check that all methods of T are collected before
// determining the result type of m (which embeds
// all methods of T).
type T interface {
m() interface {T}
E
}
var _ = T.m(nil).m().e()
type E interface {
e() int
}
// Check that unresolved forward chains are followed
// (see also comment in resolver.go, checker.typeDecl).
var _ = C.m(nil).m().e()
type A B
type B interface {
m() interface{C}
E
}
type C A
// Check that interface type comparison for identity
// does not recur endlessly.
type T1 interface {
m() interface{T1}
}
type T2 interface {
m() interface{T2}
}
func _(x T1, y T2) {
// Checking for assignability of interfaces must check
// if all methods of x are present in y, and that they
// have identical signatures. The signatures recur via
// the result type, which is an interface that embeds
// a single method m that refers to the very interface
// that contains it. This requires cycle detection in
// identity checks for interface types.
x = y
}
type T3 interface {
m() interface{T4}
}
type T4 interface {
m() interface{T3}
}
func _(x T1, y T3) {
x = y
}
// Check that interfaces are type-checked in order of
// (embedded interface) dependencies (was issue 7158).
var x1 T5 = T7(nil)
type T5 interface {
T6
}
type T6 interface {
m() T7
}
type T7 interface {
T5
}
// Actual test case from issue 7158.
func wrapNode() Node {
return wrapElement()
}
func wrapElement() Element {
return nil
}
type EventTarget interface {
AddEventListener(Event)
}
type Node interface {
EventTarget
}
type Element interface {
Node
}
type Event interface {
Target() Element
}

200
src/cmd/compile/internal/types2/testdata/cycles5.src vendored Normal file
View file

@ -0,0 +1,200 @@
// Copyright 2017 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"
// test case from issue #18395
type (
A interface { B }
B interface { C }
C interface { D; F() A }
D interface { G() B }
)
var _ = A(nil).G // G must be found
// test case from issue #21804
type sourceBridge interface {
listVersions() ([]Version, error)
}
type Constraint interface {
copyTo(*ConstraintMsg)
}
type ConstraintMsg struct{}
func (m *ConstraintMsg) asUnpairedVersion() UnpairedVersion {
return nil
}
type Version interface {
Constraint
}
type UnpairedVersion interface {
Version
}
var _ Constraint = UnpairedVersion(nil)
// derived test case from issue #21804
type (
_ interface{ m(B1) }
A1 interface{ a(D1) }
B1 interface{ A1 }
C1 interface{ B1 }
D1 interface{ C1 }
)
var _ A1 = C1(nil)
// derived test case from issue #22701
func F(x I4) interface{} {
return x.Method()
}
type Unused interface {
RefersToI1(a I1)
}
type I1 interface {
I2
I3
}
type I2 interface {
RefersToI4() I4
}
type I3 interface {
Method() interface{}
}
type I4 interface {
I1
}
// check embedding of error interface
type Error interface{ error }
var err Error
var _ = err.Error()
// more esoteric cases
type (
T1 interface { T2 }
T2 /* ERROR cycle */ T2
)
type (
T3 interface { T4 }
T4 /* ERROR cycle */ T5
T5 = T6
T6 = T7
T7 = T4
)
// arbitrary code may appear inside an interface
const n = unsafe.Sizeof(func(){})
type I interface {
m([unsafe.Sizeof(func() { I.m(nil, [n]byte{}) })]byte)
}
// test cases for varias alias cycles
type T10 /* ERROR cycle */ = *T10 // issue #25141
type T11 /* ERROR cycle */ = interface{ f(T11) } // issue #23139
// issue #18640
type (
aa = bb
bb struct {
*aa
}
)
type (
a struct{ *b }
b = c
c struct{ *b }
)
// issue #24939
type (
_ interface {
M(P)
}
M interface {
F() P
}
P = interface {
I() M
}
)
// issue #8699
type T12 /* ERROR cycle */ [len(a12)]int
var a12 = makeArray()
func makeArray() (res T12) { return }
// issue #20770
var r /* ERROR cycle */ = newReader()
func newReader() r
// variations of the theme of #8699 and #20770
var arr /* ERROR cycle */ = f()
func f() [len(arr)]int
// issue #25790
func ff(ff /* ERROR not a type */ )
func gg((gg /* ERROR not a type */ ))
type T13 /* ERROR cycle */ [len(b13)]int
var b13 T13
func g1() [unsafe.Sizeof(g1)]int
func g2() [unsafe.Sizeof(x2)]int
var x2 = g2
// verify that we get the correct sizes for the functions above
// (note: assert is statically evaluated in go/types test mode)
func init() {
assert(unsafe.Sizeof(g1) == 8)
assert(unsafe.Sizeof(x2) == 8)
}
func h() [h /* ERROR no value */ ()[0]]int { panic(0) }
var c14 /* ERROR cycle */ T14
type T14 [uintptr(unsafe.Sizeof(&c14))]byte
// issue #34333
type T15 /* ERROR cycle */ struct {
f func() T16
b T16
}
type T16 struct {
T15
}

206
src/cmd/compile/internal/types2/testdata/decls0.src vendored Normal file
View file

@ -0,0 +1,206 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// type declarations
package decls0
import "unsafe"
const pi = 3.1415
type (
N undeclared /* ERROR "undeclared" */
B bool
I int32
A [10]P
T struct {
x, y P
}
P *T
R (*R)
F func(A) I
Y interface {
f(A) I
}
S [](((P)))
M map[I]F
C chan<- I
// blank types must be typechecked
_ pi /* ERROR "not a type" */
_ struct{}
_ struct{ pi /* ERROR "not a type" */ }
)
// declarations of init
const _, init /* ERROR "cannot declare init" */ , _ = 0, 1, 2
type init /* ERROR "cannot declare init" */ struct{}
var _, init /* ERROR "cannot declare init" */ int
func init() {}
func init /* ERROR "missing function body" */ ()
func _() { const init = 0 }
func _() { type init int }
func _() { var init int; _ = init }
// invalid array types
type (
iA0 [... /* ERROR "invalid use of '...'" */ ]byte
// The error message below could be better. At the moment
// we believe an integer that is too large is not an integer.
// But at least we get an error.
iA1 [1 /* ERROR "must be integer" */ <<100]int
iA2 [- /* ERROR "invalid array length" */ 1]complex128
iA3 ["foo" /* ERROR "must be integer" */ ]string
iA4 [float64 /* ERROR "must be integer" */ (0)]int
)
type (
p1 pi.foo /* ERROR "no field or method foo" */
p2 unsafe.Pointer
)
type (
Pi pi /* ERROR "not a type" */
a /* ERROR "illegal cycle" */ a
a /* ERROR "redeclared" */ int
b /* ERROR "illegal cycle" */ c
c d
d e
e b
t *t
U V
V *W
W U
P1 *S2
P2 P1
S0 struct {
}
S1 struct {
a, b, c int
u, v, a /* ERROR "redeclared" */ float32
}
S2 struct {
S0 // embedded field
S0 /* ERROR "redeclared" */ int
}
S3 struct {
x S2
}
S4/* ERROR "illegal cycle" */ struct {
S4
}
S5 /* ERROR "illegal cycle" */ struct {
S6
}
S6 struct {
field S7
}
S7 struct {
S5
}
L1 []L1
L2 []int
A1 [10.0]int
A2 /* ERROR "illegal cycle" */ [10]A2
A3 /* ERROR "illegal cycle" */ [10]struct {
x A4
}
A4 [10]A3
F1 func()
F2 func(x, y, z float32)
F3 func(x, y, x /* ERROR "redeclared" */ float32)
F4 func() (x, y, x /* ERROR "redeclared" */ float32)
F5 func(x int) (x /* ERROR "redeclared" */ float32)
F6 func(x ...int)
I1 interface{}
I2 interface {
m1()
}
I3 interface {
m1()
m1 /* ERROR "duplicate method" */ ()
}
I4 interface {
m1(x, y, x /* ERROR "redeclared" */ float32)
m2() (x, y, x /* ERROR "redeclared" */ float32)
m3(x int) (x /* ERROR "redeclared" */ float32)
}
I5 interface {
m1(I5)
}
I6 interface {
S0 /* ERROR "not an interface" */
}
I7 interface {
I1
I1
}
I8 /* ERROR "illegal cycle" */ interface {
I8
}
I9 /* ERROR "illegal cycle" */ interface {
I10
}
I10 interface {
I11
}
I11 interface {
I9
}
C1 chan int
C2 <-chan int
C3 chan<- C3
C4 chan C5
C5 chan C6
C6 chan C4
M1 map[Last]string
M2 map[string]M2
Last int
)
// cycles in function/method declarations
// (test cases for issues #5217, #25790 and variants)
func f1(x f1 /* ERROR "not a type" */ ) {}
func f2(x *f2 /* ERROR "not a type" */ ) {}
func f3() (x f3 /* ERROR "not a type" */ ) { return }
func f4() (x *f4 /* ERROR "not a type" */ ) { return }
func (S0) m1 /* ERROR illegal cycle */ (x S0 /* ERROR value .* is not a type */ .m1) {}
func (S0) m2 /* ERROR illegal cycle */ (x *S0 /* ERROR value .* is not a type */ .m2) {}
func (S0) m3 /* ERROR illegal cycle */ () (x S0 /* ERROR value .* is not a type */ .m3) { return }
func (S0) m4 /* ERROR illegal cycle */ () (x *S0 /* ERROR value .* is not a type */ .m4) { return }
// interfaces may not have any blank methods
type BlankI interface {
_ /* ERROR "invalid method name" */ ()
_ /* ERROR "invalid method name" */ (float32) int
m()
}
// non-interface types may have multiple blank methods
type BlankT struct{}
func (BlankT) _() {}
func (BlankT) _(int) {}
func (BlankT) _() int { return 0 }
func (BlankT) _(int) int { return 0}

144
src/cmd/compile/internal/types2/testdata/decls1.src vendored Normal file
View file

@ -0,0 +1,144 @@
// 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.
// variable declarations
package decls1
import (
"math"
)
// Global variables without initialization
var (
a, b bool
c byte
d uint8
r rune
i int
j, k, l int
x, y float32
xx, yy float64
u, v complex64
uu, vv complex128
s, t string
array []byte
iface interface{}
blank _ /* ERROR "cannot use _" */
)
// Global variables with initialization
var (
s1 = i + j
s2 = i /* ERROR "mismatched types" */ + x
s3 = c + d
s4 = s + t
s5 = s /* ERROR "invalid operation" */ / t
s6 = array[t1]
s7 = array[x /* ERROR "integer" */]
s8 = &a
s10 = &42 /* ERROR "cannot take address" */
s11 = &v
s12 = -(u + *t11) / *&v
s13 = a /* ERROR "shifted operand" */ << d
s14 = i << j
s18 = math.Pi * 10.0
s19 = s1 /* ERROR "cannot call" */ ()
s20 = f0 /* ERROR "no value" */ ()
s21 = f6(1, s1, i)
s22 = f6(1, s1, uu /* ERROR "cannot use .* in argument" */ )
t1 int = i + j
t2 int = i /* ERROR "mismatched types" */ + x
t3 int = c /* ERROR "cannot use .* variable declaration" */ + d
t4 string = s + t
t5 string = s /* ERROR "invalid operation" */ / t
t6 byte = array[t1]
t7 byte = array[x /* ERROR "must be integer" */]
t8 *int = & /* ERROR "cannot use .* variable declaration" */ a
t10 *int = &42 /* ERROR "cannot take address" */
t11 *complex64 = &v
t12 complex64 = -(u + *t11) / *&v
t13 int = a /* ERROR "shifted operand" */ << d
t14 int = i << j
t15 math /* ERROR "not in selector" */
t16 math.xxx /* ERROR "not declared" */
t17 math /* ERROR "not a type" */ .Pi
t18 float64 = math.Pi * 10.0
t19 int = t1 /* ERROR "cannot call" */ ()
t20 int = f0 /* ERROR "no value" */ ()
t21 int = a /* ERROR "cannot use .* variable declaration" */
)
// Various more complex expressions
var (
u1 = x /* ERROR "not an interface" */ .(int)
u2 = iface.([]int)
u3 = iface.(a /* ERROR "not a type" */ )
u4, ok = iface.(int)
u5, ok2, ok3 = iface /* ERROR "cannot initialize" */ .(int)
)
// Constant expression initializations
var (
v1 = 1 /* ERROR "cannot convert" */ + "foo"
v2 = c + 255
v3 = c + 256 /* ERROR "overflows" */
v4 = r + 2147483647
v5 = r + 2147483648 /* ERROR "overflows" */
v6 = 42
v7 = v6 + 9223372036854775807
v8 = v6 + 9223372036854775808 /* ERROR "overflows" */
v9 = i + 1 << 10
v10 byte = 1024 /* ERROR "overflows" */
v11 = xx/yy*yy - xx
v12 = true && false
v13 = nil /* ERROR "use of untyped nil" */
)
// Multiple assignment expressions
var (
m1a, m1b = 1, 2
m2a, m2b, m2c /* ERROR "missing init expr for m2c" */ = 1, 2
m3a, m3b = 1, 2, 3 /* ERROR "extra init expr 3" */
)
func _() {
var (
m1a, m1b = 1, 2
m2a, m2b, m2c /* ERROR "missing init expr for m2c" */ = 1, 2
m3a, m3b = 1, 2, 3 /* ERROR "extra init expr 3" */
)
_, _ = m1a, m1b
_, _, _ = m2a, m2b, m2c
_, _ = m3a, m3b
}
// Declaration of parameters and results
func f0() {}
func f1(a /* ERROR "not a type" */) {}
func f2(a, b, c d /* ERROR "not a type" */) {}
func f3() int { return 0 }
func f4() a /* ERROR "not a type" */ { return 0 }
func f5() (a, b, c d /* ERROR "not a type" */) { return }
func f6(a, b, c int) complex128 { return 0 }
// Declaration of receivers
type T struct{}
func (T) m0() {}
func (*T) m1() {}
func (x T) m2() {}
func (x *T) m3() {}
// Initialization functions
func init() {}
func /* ERROR "no arguments and no return values" */ init(int) {}
func /* ERROR "no arguments and no return values" */ init() int { return 0 }
func /* ERROR "no arguments and no return values" */ init(int) int { return 0 }
func (T) init(int) int { return 0 }

309
src/cmd/compile/internal/types2/testdata/decls3.src vendored Normal file
View file

@ -0,0 +1,309 @@
// 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.
// embedded types
package decls3
import "unsafe"
import "fmt"
// fields with the same name at the same level cancel each other out
func _() {
type (
T1 struct { X int }
T2 struct { X int }
T3 struct { T1; T2 } // X is embedded twice at the same level via T1->X, T2->X
)
var t T3
_ = t.X /* ERROR "ambiguous selector t.X" */
}
func _() {
type (
T1 struct { X int }
T2 struct { T1 }
T3 struct { T1 }
T4 struct { T2; T3 } // X is embedded twice at the same level via T2->T1->X, T3->T1->X
)
var t T4
_ = t.X /* ERROR "ambiguous selector t.X" */
}
func issue4355() {
type (
T1 struct {X int}
T2 struct {T1}
T3 struct {T2}
T4 struct {T2}
T5 struct {T3; T4} // X is embedded twice at the same level via T3->T2->T1->X, T4->T2->T1->X
)
var t T5
_ = t.X /* ERROR "ambiguous selector t.X" */
}
func _() {
type State int
type A struct{ State }
type B struct{ fmt.State }
type T struct{ A; B }
var t T
_ = t.State /* ERROR "ambiguous selector t.State" */
}
// Embedded fields can be predeclared types.
func _() {
type T0 struct{
int
float32
f int
}
var x T0
_ = x.int
_ = x.float32
_ = x.f
type T1 struct{
T0
}
var y T1
_ = y.int
_ = y.float32
_ = y.f
}
// Restrictions on embedded field types.
func _() {
type I1 interface{}
type I2 interface{}
type P1 *int
type P2 *int
type UP unsafe.Pointer
type T1 struct {
I1
* /* ERROR "cannot be a pointer to an interface" */ I2
* /* ERROR "cannot be a pointer to an interface" */ error
P1 /* ERROR "cannot be a pointer" */
* /* ERROR "cannot be a pointer" */ P2
}
// unsafe.Pointers are treated like regular pointers when embedded
type T2 struct {
unsafe /* ERROR "cannot be unsafe.Pointer" */ .Pointer
*/* ERROR "cannot be unsafe.Pointer" */ /* ERROR "Pointer redeclared" */ unsafe.Pointer
UP /* ERROR "cannot be unsafe.Pointer" */
* /* ERROR "cannot be unsafe.Pointer" */ /* ERROR "UP redeclared" */ UP
}
}
// Named types that are pointers.
type S struct{ x int }
func (*S) m() {}
type P *S
func _() {
var s *S
_ = s.x
_ = s.m
var p P
_ = p.x
_ = p.m /* ERROR "no field or method" */
_ = P.m /* ERROR "no field or method" */
}
// Borrowed from the FieldByName test cases in reflect/all_test.go.
type D1 struct {
d int
}
type D2 struct {
d int
}
type S0 struct {
A, B, C int
D1
D2
}
type S1 struct {
B int
S0
}
type S2 struct {
A int
*S1
}
type S1x struct {
S1
}
type S1y struct {
S1
}
type S3 struct {
S1x
S2
D, E int
*S1y
}
type S4 struct {
*S4
A int
}
// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
type S5 struct {
S6
S7
S8
}
type S6 struct {
X int
}
type S7 S6
type S8 struct {
S9
}
type S9 struct {
X int
Y int
}
// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
type S10 struct {
S11
S12
S13
}
type S11 struct {
S6
}
type S12 struct {
S6
}
type S13 struct {
S8
}
func _() {
_ = struct{}{}.Foo /* ERROR "no field or method" */
_ = S0{}.A
_ = S0{}.D /* ERROR "no field or method" */
_ = S1{}.A
_ = S1{}.B
_ = S1{}.S0
_ = S1{}.C
_ = S2{}.A
_ = S2{}.S1
_ = S2{}.B
_ = S2{}.C
_ = S2{}.D /* ERROR "no field or method" */
_ = S3{}.S1 /* ERROR "ambiguous selector \(S3 literal\).S1" */
_ = S3{}.A
_ = S3{}.B /* ERROR "ambiguous selector" \(S3 literal\).B */
_ = S3{}.D
_ = S3{}.E
_ = S4{}.A
_ = S4{}.B /* ERROR "no field or method" */
_ = S5{}.X /* ERROR "ambiguous selector \(S5 literal\).X" */
_ = S5{}.Y
_ = S10{}.X /* ERROR "ambiguous selector \(S10 literal\).X" */
_ = S10{}.Y
}
// Borrowed from the FieldByName benchmark in reflect/all_test.go.
type R0 struct {
*R1
*R2
*R3
*R4
}
type R1 struct {
*R5
*R6
*R7
*R8
}
type R2 R1
type R3 R1
type R4 R1
type R5 struct {
*R9
*R10
*R11
*R12
}
type R6 R5
type R7 R5
type R8 R5
type R9 struct {
*R13
*R14
*R15
*R16
}
type R10 R9
type R11 R9
type R12 R9
type R13 struct {
*R17
*R18
*R19
*R20
}
type R14 R13
type R15 R13
type R16 R13
type R17 struct {
*R21
*R22
*R23
*R24
}
type R18 R17
type R19 R17
type R20 R17
type R21 struct {
X int
}
type R22 R21
type R23 R21
type R24 R21
var _ = R0{}.X /* ERROR "ambiguous selector \(R0 literal\).X" */

199
src/cmd/compile/internal/types2/testdata/decls4.src vendored Normal file
View file

@ -0,0 +1,199 @@
// Copyright 2016 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.
// type aliases
package decls4
type (
T0 [10]int
T1 []byte
T2 struct {
x int
}
T3 interface{
m() T2
}
T4 func(int, T0) chan T2
)
type (
Ai = int
A0 = T0
A1 = T1
A2 = T2
A3 = T3
A4 = T4
A10 = [10]int
A11 = []byte
A12 = struct {
x int
}
A13 = interface{
m() A2
}
A14 = func(int, A0) chan A2
)
// check assignment compatibility due to equality of types
var (
xi_ int
ai Ai = xi_
x0 T0
a0 A0 = x0
x1 T1
a1 A1 = x1
x2 T2
a2 A2 = x2
x3 T3
a3 A3 = x3
x4 T4
a4 A4 = x4
)
// alias receiver types
func (Ai /* ERROR "invalid receiver" */) m1() {}
func (T0) m1() {}
func (A0) m1 /* ERROR already declared */ () {}
func (A0) m2 () {}
func (A3 /* ERROR invalid receiver */ ) m1 () {}
func (A10 /* ERROR invalid receiver */ ) m1() {}
// x0 has methods m1, m2 declared via receiver type names T0 and A0
var _ interface{ m1(); m2() } = x0
// alias receiver types (test case for issue #23042)
type T struct{}
var (
_ = T.m
_ = T{}.m
_ interface{m()} = T{}
)
var (
_ = T.n
_ = T{}.n
_ interface{m(); n()} = T{}
)
type U = T
func (U) m() {}
// alias receiver types (long type declaration chains)
type (
V0 = V1
V1 = (V2)
V2 = ((V3))
V3 = T
)
func (V0) m /* ERROR already declared */ () {}
func (V1) n() {}
// alias receiver types (invalid due to cycles)
type (
W0 /* ERROR illegal cycle */ = W1
W1 = (W2)
W2 = ((W0))
)
func (W0) m() {} // no error expected (due to above cycle error)
func (W1) n() {}
// alias receiver types (invalid due to builtin underlying type)
type (
B0 = B1
B1 = B2
B2 = int
)
func (B0 /* ERROR invalid receiver */ ) m() {}
func (B1 /* ERROR invalid receiver */ ) n() {}
// cycles
type (
C2 /* ERROR illegal cycle */ = C2
C3 /* ERROR illegal cycle */ = C4
C4 = C3
C5 struct {
f *C6
}
C6 = C5
C7 /* ERROR illegal cycle */ struct {
f C8
}
C8 = C7
)
// embedded fields
var (
s0 struct { T0 }
s1 struct { A0 } = s0 /* ERROR cannot use */ // embedded field names are different
)
// embedding and lookup of fields and methods
func _(s struct{A0}) { s.A0 = x0 }
type eX struct{xf int}
func (eX) xm()
type eY = struct{eX} // field/method set of eY includes xf, xm
type eZ = *struct{eX} // field/method set of eZ includes xf, xm
type eA struct {
eX // eX contributes xf, xm to eA
}
type eA2 struct {
*eX // *eX contributes xf, xm to eA
}
type eB struct {
eY // eY contributes xf, xm to eB
}
type eB2 struct {
*eY // *eY contributes xf, xm to eB
}
type eC struct {
eZ // eZ contributes xf, xm to eC
}
var (
_ = eA{}.xf
_ = eA{}.xm
_ = eA2{}.xf
_ = eA2{}.xm
_ = eB{}.xf
_ = eB{}.xm
_ = eB2{}.xf
_ = eB2{}.xm
_ = eC{}.xf
_ = eC{}.xm
)
// ambiguous selectors due to embedding via type aliases
type eD struct {
eY
eZ
}
var (
_ = eD{}.xf /* ERROR ambiguous selector \(eD literal\).xf */
_ = eD{}.xm /* ERROR ambiguous selector \(eD literal\).xm */
)
var (
_ interface{ xm() } = eD /* ERROR missing method xm */ {}
)

10
src/cmd/compile/internal/types2/testdata/decls5.src vendored Normal file
View file

@ -0,0 +1,10 @@
// Copyright 2017 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
// declarations of main
const _, main /* ERROR "cannot declare main" */ , _ = 0, 1, 2
type main /* ERROR "cannot declare main" */ struct{}
var _, main /* ERROR "cannot declare main" */ int

60
src/cmd/compile/internal/types2/testdata/errors.src vendored Normal file
View file

@ -0,0 +1,60 @@
// 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 errors
// Testing precise operand formatting in error messages
// (matching messages are regular expressions, hence the \'s).
func f(x int, m map[string]int) {
// no values
_ = f /* ERROR "f\(0, m\) \(no value\) used as value" */ (0, m)
// built-ins
_ = println /* ERROR "println \(built-in\) must be called" */
// types
_ = complex128 /* ERROR "complex128 \(type\) is not an expression" */
// constants
const c1 = 991
const c2 float32 = 0.5
0 /* ERROR "0 \(untyped int constant\) is not used" */
c1 /* ERROR "c1 \(untyped int constant 991\) is not used" */
c2 /* ERROR "c2 \(constant 0.5 of type float32\) is not used" */
c1 /* ERROR "c1 \+ c2 \(constant 991.5 of type float32\) is not used" */ + c2
// variables
x /* ERROR "x \(variable of type int\) is not used" */
// values
x /* ERROR "x != x \(untyped bool value\) is not used" */ != x
x /* ERROR "x \+ x \(value of type int\) is not used" */ + x
// value, ok's
const s = "foo"
m /* ERROR "m\[s\] \(map index expression of type int\) is not used" */ [s]
}
// Valid ERROR comments can have a variety of forms.
func _() {
0 /* ERROR "0 .* is not used" */
0 /* ERROR 0 .* is not used */
0 // ERROR "0 .* is not used"
0 // ERROR 0 .* is not used
}
// Don't report spurious errors as a consequence of earlier errors.
// Add more tests as needed.
func _() {
if err := foo /* ERROR undeclared */ (); err != nil /* no error here */ {}
}
// Use unqualified names for package-local objects.
type T struct{}
var _ int = T /* ERROR value of type T */ {} // use T in error message rather then errors.T
// Don't report errors containing "invalid type" (issue #24182).
func _(x *missing /* ERROR undeclared name: missing */ ) {
x.m() // there shouldn't be an error here referring to *invalid type
}

180
src/cmd/compile/internal/types2/testdata/expr0.src vendored Normal file
View file

@ -0,0 +1,180 @@
// 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.
// unary expressions
package expr0
type mybool bool
var (
// bool
b0 = true
b1 bool = b0
b2 = !true
b3 = !b1
b4 bool = !true
b5 bool = !b4
b6 = +b0 /* ERROR "not defined" */
b7 = -b0 /* ERROR "not defined" */
b8 = ^b0 /* ERROR "not defined" */
b9 = *b0 /* ERROR "cannot indirect" */
b10 = &true /* ERROR "cannot take address" */
b11 = &b0
b12 = <-b0 /* ERROR "cannot receive" */
b13 = & & /* ERROR "cannot take address" */ b0
// byte
_ = byte(0)
_ = byte(- /* ERROR "cannot convert" */ 1)
_ = - /* ERROR "-byte\(1\) \(constant -1 of type byte\) overflows byte" */ byte(1) // test for issue 11367
_ = byte /* ERROR "overflows byte" */ (0) - byte(1)
// int
i0 = 1
i1 int = i0
i2 = +1
i3 = +i0
i4 int = +1
i5 int = +i4
i6 = -1
i7 = -i0
i8 int = -1
i9 int = -i4
i10 = !i0 /* ERROR "not defined" */
i11 = ^1
i12 = ^i0
i13 int = ^1
i14 int = ^i4
i15 = *i0 /* ERROR "cannot indirect" */
i16 = &i0
i17 = *i16
i18 = <-i16 /* ERROR "cannot receive" */
// uint
u0 = uint(1)
u1 uint = u0
u2 = +1
u3 = +u0
u4 uint = +1
u5 uint = +u4
u6 = -1
u7 = -u0
u8 uint = - /* ERROR "overflows" */ 1
u9 uint = -u4
u10 = !u0 /* ERROR "not defined" */
u11 = ^1
u12 = ^i0
u13 uint = ^ /* ERROR "overflows" */ 1
u14 uint = ^u4
u15 = *u0 /* ERROR "cannot indirect" */
u16 = &u0
u17 = *u16
u18 = <-u16 /* ERROR "cannot receive" */
u19 = ^uint(0)
// float64
f0 = float64(1)
f1 float64 = f0
f2 = +1
f3 = +f0
f4 float64 = +1
f5 float64 = +f4
f6 = -1
f7 = -f0
f8 float64 = -1
f9 float64 = -f4
f10 = !f0 /* ERROR "not defined" */
f11 = ^1
f12 = ^i0
f13 float64 = ^1
f14 float64 = ^f4 /* ERROR "not defined" */
f15 = *f0 /* ERROR "cannot indirect" */
f16 = &f0
f17 = *u16
f18 = <-u16 /* ERROR "cannot receive" */
// complex128
c0 = complex128(1)
c1 complex128 = c0
c2 = +1
c3 = +c0
c4 complex128 = +1
c5 complex128 = +c4
c6 = -1
c7 = -c0
c8 complex128 = -1
c9 complex128 = -c4
c10 = !c0 /* ERROR "not defined" */
c11 = ^1
c12 = ^i0
c13 complex128 = ^1
c14 complex128 = ^c4 /* ERROR "not defined" */
c15 = *c0 /* ERROR "cannot indirect" */
c16 = &c0
c17 = *u16
c18 = <-u16 /* ERROR "cannot receive" */
// string
s0 = "foo"
s1 = +"foo" /* ERROR "not defined" */
s2 = -s0 /* ERROR "not defined" */
s3 = !s0 /* ERROR "not defined" */
s4 = ^s0 /* ERROR "not defined" */
s5 = *s4
s6 = &s4
s7 = *s6
s8 = <-s7
// channel
ch chan int
rc <-chan float64
sc chan <- string
ch0 = +ch /* ERROR "not defined" */
ch1 = -ch /* ERROR "not defined" */
ch2 = !ch /* ERROR "not defined" */
ch3 = ^ch /* ERROR "not defined" */
ch4 = *ch /* ERROR "cannot indirect" */
ch5 = &ch
ch6 = *ch5
ch7 = <-ch
ch8 = <-rc
ch9 = <-sc /* ERROR "cannot receive" */
ch10, ok = <-ch
// ok is of type bool
ch11, myok = <-ch
_ mybool = myok /* ERROR "cannot use .* in variable declaration" */
)
// address of composite literals
type T struct{x, y int}
func f() T { return T{} }
var (
_ = &T{1, 2}
_ = &[...]int{}
_ = &[]int{}
_ = &[]int{}
_ = &map[string]T{}
_ = &(T{1, 2})
_ = &((((T{1, 2}))))
_ = &f /* ERROR "cannot take address" */ ()
)
// recursive pointer types
type P *P
var (
p1 P = new(P)
p2 P = *p1
p3 P = &p2
)
func g() (a, b int) { return }
func _() {
_ = -g /* ERROR 2-valued g */ ()
_ = <-g /* ERROR 2-valued g */ ()
}

127
src/cmd/compile/internal/types2/testdata/expr1.src vendored Normal file
View file

@ -0,0 +1,127 @@
// 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.
// binary expressions
package expr1
type mybool bool
func _(x, y bool, z mybool) {
x = x || y
x = x || true
x = x || false
x = x && y
x = x && true
x = x && false
z = z /* ERROR mismatched types */ || y
z = z || true
z = z || false
z = z /* ERROR mismatched types */ && y
z = z && true
z = z && false
}
type myint int
func _(x, y int, z myint) {
x = x + 1
x = x + 1.0
x = x + 1.1 // ERROR truncated to int
x = x + y
x = x - y
x = x * y
x = x / y
x = x % y
x = x << y
x = x >> y
z = z + 1
z = z + 1.0
z = z + 1.1 // ERROR truncated to int
z = z /* ERROR mismatched types */ + y
z = z /* ERROR mismatched types */ - y
z = z /* ERROR mismatched types */ * y
z = z /* ERROR mismatched types */ / y
z = z /* ERROR mismatched types */ % y
z = z << y
z = z >> y
}
type myuint uint
func _(x, y uint, z myuint) {
x = x + 1
x = x + - /* ERROR overflows uint */ 1
x = x + 1.0
x = x + 1.1 // ERROR truncated to uint
x = x + y
x = x - y
x = x * y
x = x / y
x = x % y
x = x << y
x = x >> y
z = z + 1
z = x + - /* ERROR overflows uint */ 1
z = z + 1.0
z = z + 1.1 // ERROR truncated to uint
z = z /* ERROR mismatched types */ + y
z = z /* ERROR mismatched types */ - y
z = z /* ERROR mismatched types */ * y
z = z /* ERROR mismatched types */ / y
z = z /* ERROR mismatched types */ % y
z = z << y
z = z >> y
}
type myfloat64 float64
func _(x, y float64, z myfloat64) {
x = x + 1
x = x + -1
x = x + 1.0
x = x + 1.1
x = x + y
x = x - y
x = x * y
x = x / y
x = x /* ERROR not defined */ % y
x = x /* ERROR operand x .* must be integer */ << y
x = x /* ERROR operand x .* must be integer */ >> y
z = z + 1
z = z + -1
z = z + 1.0
z = z + 1.1
z = z /* ERROR mismatched types */ + y
z = z /* ERROR mismatched types */ - y
z = z /* ERROR mismatched types */ * y
z = z /* ERROR mismatched types */ / y
z = z /* ERROR mismatched types */ % y
z = z /* ERROR operand z .* must be integer */ << y
z = z /* ERROR operand z .* must be integer */ >> y
}
type mystring string
func _(x, y string, z mystring) {
x = x + "foo"
x = x /* ERROR not defined */ - "foo"
x = x + 1 // ERROR cannot convert
x = x + y
x = x /* ERROR not defined */ - y
x = x * 10 // ERROR cannot convert
}
func f() (a, b int) { return }
func _(x int) {
_ = f /* ERROR 2-valued f */ () + 1
_ = x + f /* ERROR 2-valued f */ ()
_ = f /* ERROR 2-valued f */ () + f
_ = f /* ERROR 2-valued f */ () + f /* ERROR 2-valued f */ ()
}

260
src/cmd/compile/internal/types2/testdata/expr2.src vendored Normal file
View file

@ -0,0 +1,260 @@
// 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.
// comparisons
package expr2
func _bool() {
const t = true == true
const f = true == false
_ = t /* ERROR "cannot compare" */ < f
_ = 0 /* ERROR "cannot convert" */ == t
var b bool
var x, y float32
b = x < y
_ = b
_ = struct{b bool}{x < y}
}
// corner cases
var (
v0 = nil /* ERROR "cannot compare" */ == nil
)
func arrays() {
// basics
var a, b [10]int
_ = a == b
_ = a != b
_ = a /* ERROR < not defined */ < b
_ = a == nil /* ERROR cannot convert */
type C [10]int
var c C
_ = a == c
type D [10]int
var d D
_ = c /* ERROR mismatched types */ == d
var e [10]func() int
_ = e /* ERROR == not defined */ == e
}
func structs() {
// basics
var s, t struct {
x int
a [10]float32
_ bool
}
_ = s == t
_ = s != t
_ = s /* ERROR < not defined */ < t
_ = s == nil /* ERROR cannot convert */
type S struct {
x int
a [10]float32
_ bool
}
type T struct {
x int
a [10]float32
_ bool
}
var ss S
var tt T
_ = s == ss
_ = ss /* ERROR mismatched types */ == tt
var u struct {
x int
a [10]map[string]int
}
_ = u /* ERROR cannot compare */ == u
}
func pointers() {
// nil
_ = nil /* ERROR == not defined */ == nil
_ = nil /* ERROR != not defined */ != nil
_ = nil /* ERROR < not defined */ < nil
_ = nil /* ERROR <= not defined */ <= nil
_ = nil /* ERROR > not defined */ > nil
_ = nil /* ERROR >= not defined */ >= nil
// basics
var p, q *int
_ = p == q
_ = p != q
_ = p == nil
_ = p != nil
_ = nil == q
_ = nil != q
_ = p /* ERROR < not defined */ < q
_ = p /* ERROR <= not defined */ <= q
_ = p /* ERROR > not defined */ > q
_ = p /* ERROR >= not defined */ >= q
// various element types
type (
S1 struct{}
S2 struct{}
P1 *S1
P2 *S2
)
var (
ps1 *S1
ps2 *S2
p1 P1
p2 P2
)
_ = ps1 == ps1
_ = ps1 /* ERROR mismatched types */ == ps2
_ = ps2 /* ERROR mismatched types */ == ps1
_ = p1 == p1
_ = p1 /* ERROR mismatched types */ == p2
_ = p1 == ps1
}
func channels() {
// basics
var c, d chan int
_ = c == d
_ = c != d
_ = c == nil
_ = c /* ERROR < not defined */ < d
// various element types (named types)
type (
C1 chan int
C1r <-chan int
C1s chan<- int
C2 chan float32
)
var (
c1 C1
c1r C1r
c1s C1s
c1a chan int
c2 C2
)
_ = c1 == c1
_ = c1 /* ERROR mismatched types */ == c1r
_ = c1 /* ERROR mismatched types */ == c1s
_ = c1r /* ERROR mismatched types */ == c1s
_ = c1 == c1a
_ = c1a == c1
_ = c1 /* ERROR mismatched types */ == c2
_ = c1a /* ERROR mismatched types */ == c2
// various element types (unnamed types)
var (
d1 chan int
d1r <-chan int
d1s chan<- int
d1a chan<- int
d2 chan float32
)
_ = d1 == d1
_ = d1 == d1r
_ = d1 == d1s
_ = d1r /* ERROR mismatched types */ == d1s
_ = d1 == d1a
_ = d1a == d1
_ = d1 /* ERROR mismatched types */ == d2
_ = d1a /* ERROR mismatched types */ == d2
}
// for interfaces test
type S1 struct{}
type S11 struct{}
type S2 struct{}
func (*S1) m() int
func (*S11) m() int
func (*S11) n()
func (*S2) m() float32
func interfaces() {
// basics
var i, j interface{ m() int }
_ = i == j
_ = i != j
_ = i == nil
_ = i /* ERROR < not defined */ < j
// various interfaces
var ii interface { m() int; n() }
var k interface { m() float32 }
_ = i == ii
_ = i /* ERROR mismatched types */ == k
// interfaces vs values
var s1 S1
var s11 S11
var s2 S2
_ = i == 0 /* ERROR cannot convert */
_ = i /* ERROR mismatched types */ == s1
_ = i == &s1
_ = i == &s11
_ = i /* ERROR mismatched types */ == s2
_ = i /* ERROR mismatched types */ == &s2
// issue #28164
// testcase from issue
_ = interface /* ERROR cannot compare */ {}(nil) == []int(nil)
// related cases
var e interface{}
var s []int
var x int
_ = e /* ERROR cannot compare */ == s
_ = s /* ERROR cannot compare */ == e
_ = e /* ERROR cannot compare */ < x
_ = x /* ERROR cannot compare */ < e
}
func slices() {
// basics
var s []int
_ = s == nil
_ = s != nil
_ = s /* ERROR < not defined */ < nil
// slices are not otherwise comparable
_ = s /* ERROR == not defined */ == s
_ = s /* ERROR < not defined */ < s
}
func maps() {
// basics
var m map[string]int
_ = m == nil
_ = m != nil
_ = m /* ERROR < not defined */ < nil
// maps are not otherwise comparable
_ = m /* ERROR == not defined */ == m
_ = m /* ERROR < not defined */ < m
}
func funcs() {
// basics
var f func(int) float32
_ = f == nil
_ = f != nil
_ = f /* ERROR < not defined */ < nil
// funcs are not otherwise comparable
_ = f /* ERROR == not defined */ == f
_ = f /* ERROR < not defined */ < f
}

562
src/cmd/compile/internal/types2/testdata/expr3.src vendored Normal file
View file

@ -0,0 +1,562 @@
// 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 expr3
import "time"
func indexes() {
_ = 1 /* ERROR "cannot index" */ [0]
_ = indexes /* ERROR "cannot index" */ [0]
_ = ( /* ERROR "cannot slice" */ 12 + 3)[1:2]
var a [10]int
_ = a[true /* ERROR "cannot convert" */ ]
_ = a["foo" /* ERROR "cannot convert" */ ]
_ = a[1.1 /* ERROR "truncated" */ ]
_ = a[1.0]
_ = a[- /* ERROR "negative" */ 1]
_ = a[- /* ERROR "negative" */ 1 :]
_ = a[: - /* ERROR "negative" */ 1]
_ = a[: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
_ = a[0: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
_ = a[0: /* ERROR "2nd index required" */ :10]
_ = a[:10:10]
var a0 int
a0 = a[0]
_ = a0
var a1 int32
a1 = a /* ERROR "cannot use .* in assignment" */ [1]
_ = a1
_ = a[9]
_ = a[10 /* ERROR "index .* out of bounds" */ ]
_ = a[1 /* ERROR "overflows" */ <<100]
_ = a[10:]
_ = a[:10]
_ = a[10:10]
_ = a[11 /* ERROR "index .* out of bounds" */ :]
_ = a[: 11 /* ERROR "index .* out of bounds" */ ]
_ = a[: 1 /* ERROR "overflows" */ <<100]
_ = a[:10:10]
_ = a[:11 /* ERROR "index .* out of bounds" */ :10]
_ = a[:10:11 /* ERROR "index .* out of bounds" */ ]
_ = a[10:0:10] /* ERROR "invalid slice indices" */
_ = a[0:10:0] /* ERROR "invalid slice indices" */
_ = a[10:0:0] /* ERROR "invalid slice indices" */
_ = &a /* ERROR "cannot take address" */ [:10]
pa := &a
_ = pa[9]
_ = pa[10 /* ERROR "index .* out of bounds" */ ]
_ = pa[1 /* ERROR "overflows" */ <<100]
_ = pa[10:]
_ = pa[:10]
_ = pa[10:10]
_ = pa[11 /* ERROR "index .* out of bounds" */ :]
_ = pa[: 11 /* ERROR "index .* out of bounds" */ ]
_ = pa[: 1 /* ERROR "overflows" */ <<100]
_ = pa[:10:10]
_ = pa[:11 /* ERROR "index .* out of bounds" */ :10]
_ = pa[:10:11 /* ERROR "index .* out of bounds" */ ]
_ = pa[10:0:10] /* ERROR "invalid slice indices" */
_ = pa[0:10:0] /* ERROR "invalid slice indices" */
_ = pa[10:0:0] /* ERROR "invalid slice indices" */
_ = &pa /* ERROR "cannot take address" */ [:10]
var b [0]int
_ = b[0 /* ERROR "index .* out of bounds" */ ]
_ = b[:]
_ = b[0:]
_ = b[:0]
_ = b[0:0]
_ = b[0:0:0]
_ = b[1 /* ERROR "index .* out of bounds" */ :0:0]
var s []int
_ = s[- /* ERROR "negative" */ 1]
_ = s[- /* ERROR "negative" */ 1 :]
_ = s[: - /* ERROR "negative" */ 1]
_ = s[0]
_ = s[1:2]
_ = s[2:1] /* ERROR "invalid slice indices" */
_ = s[2:]
_ = s[: 1 /* ERROR "overflows" */ <<100]
_ = s[1 /* ERROR "overflows" */ <<100 :]
_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
_ = s[: /* ERROR "2nd index required" */ : /* ERROR "3rd index required" */ ]
_ = s[:10:10]
_ = s[10:0:10] /* ERROR "invalid slice indices" */
_ = s[0:10:0] /* ERROR "invalid slice indices" */
_ = s[10:0:0] /* ERROR "invalid slice indices" */
_ = &s /* ERROR "cannot take address" */ [:10]
var m map[string]int
_ = m[0 /* ERROR "cannot convert" */ ]
_ = m /* ERROR "cannot slice" */ ["foo" : "bar"]
_ = m["foo"]
// ok is of type bool
type mybool bool
var ok mybool
_, ok = m["bar"]
_ = ok
var t string
_ = t[- /* ERROR "negative" */ 1]
_ = t[- /* ERROR "negative" */ 1 :]
_ = t[: - /* ERROR "negative" */ 1]
_ = t /* ERROR "3-index slice of string" */ [1:2:3]
_ = "foo" /* ERROR "3-index slice of string" */ [1:2:3]
var t0 byte
t0 = t[0]
_ = t0
var t1 rune
t1 = t /* ERROR "cannot use .* in assignment" */ [2]
_ = t1
_ = ("foo" + "bar")[5]
_ = ("foo" + "bar")[6 /* ERROR "index .* out of bounds" */ ]
const c = "foo"
_ = c[- /* ERROR "negative" */ 1]
_ = c[- /* ERROR "negative" */ 1 :]
_ = c[: - /* ERROR "negative" */ 1]
var c0 byte
c0 = c[0]
_ = c0
var c2 float32
c2 = c /* ERROR "cannot use .* in assignment" */ [2]
_ = c[3 /* ERROR "index .* out of bounds" */ ]
_ = ""[0 /* ERROR "index .* out of bounds" */ ]
_ = c2
_ = s[1<<30] // no compile-time error here
// issue 4913
type mystring string
var ss string
var ms mystring
var i, j int
ss = "foo"[1:2]
ss = "foo"[i:j]
ms = "foo" /* ERROR "cannot use .* in assignment" */ [1:2]
ms = "foo" /* ERROR "cannot use .* in assignment" */ [i:j]
_, _ = ss, ms
}
type T struct {
x int
y func()
}
func (*T) m() {}
func method_expressions() {
_ = T.a /* ERROR "no field or method" */
_ = T.x /* ERROR "has no method" */
_ = T.m /* ERROR "cannot call pointer method m on T" */
_ = (*T).m
var f func(*T) = T.m /* ERROR "cannot call pointer method m on T" */
var g func(*T) = (*T).m
_, _ = f, g
_ = T.y /* ERROR "has no method" */
_ = (*T).y /* ERROR "has no method" */
}
func struct_literals() {
type T0 struct {
a, b, c int
}
type T1 struct {
T0
a, b int
u float64
s string
}
// keyed elements
_ = T1{}
_ = T1{a: 0, 1 /* ERROR "mixture of .* elements" */ }
_ = T1{aa /* ERROR "unknown field" */ : 0}
_ = T1{1 /* ERROR "invalid field name" */ : 0}
_ = T1{a: 0, s: "foo", u: 0, a /* ERROR "duplicate field" */: 10}
_ = T1{a: "foo" /* ERROR "cannot convert" */ }
_ = T1{c /* ERROR "unknown field" */ : 0}
_ = T1{T0: { /* ERROR "missing type" */ }} // struct literal element type may not be elided
_ = T1{T0: T0{}}
_ = T1{T0 /* ERROR "invalid field name" */ .a: 0}
// unkeyed elements
_ = T0{1, 2, 3}
_ = T0{1, b /* ERROR "mixture" */ : 2, 3}
_ = T0{1, 2} /* ERROR "too few values" */
_ = T0{1, 2, 3, 4 /* ERROR "too many values" */ }
_ = T0{1, "foo" /* ERROR "cannot convert" */, 3.4 /* ERROR "truncated" */}
// invalid type
type P *struct{
x int
}
_ = P /* ERROR "invalid composite literal type" */ {}
// unexported fields
_ = time.Time{}
_ = time.Time{sec /* ERROR "unknown field" */ : 0}
_ = time.Time{
0 /* ERROR implicit assignment to unexported field wall in time.Time literal */,
0 /* ERROR implicit assignment */ ,
nil /* ERROR implicit assignment */ ,
}
}
func array_literals() {
type A0 [0]int
_ = A0{}
_ = A0{0 /* ERROR "index .* out of bounds" */}
_ = A0{0 /* ERROR "index .* out of bounds" */ : 0}
type A1 [10]int
_ = A1{}
_ = A1{0, 1, 2}
_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
_ = A1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /* ERROR "index .* out of bounds" */ }
_ = A1{- /* ERROR "negative" */ 1: 0}
_ = A1{8: 8, 9}
_ = A1{8: 8, 9, 10 /* ERROR "index .* out of bounds" */ }
_ = A1{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
_ = A1{5: 5, 6, 7, 3: 3, 4}
_ = A1{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
_ = A1{10 /* ERROR "index .* out of bounds" */ : 10, 10 /* ERROR "index .* out of bounds" */ : 10}
_ = A1{5: 5, 6, 7, 3: 3, 1 /* ERROR "overflows" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
_ = A1{2.0}
_ = A1{2.1 /* ERROR "truncated" */ }
_ = A1{"foo" /* ERROR "cannot convert" */ }
// indices must be integer constants
i := 1
const f = 2.1
const s = "foo"
_ = A1{i /* ERROR "index i must be integer constant" */ : 0}
_ = A1{f /* ERROR "truncated" */ : 0}
_ = A1{s /* ERROR "cannot convert" */ : 0}
a0 := [...]int{}
assert(len(a0) == 0)
a1 := [...]int{0, 1, 2}
assert(len(a1) == 3)
var a13 [3]int
var a14 [4]int
a13 = a1
a14 = a1 /* ERROR "cannot use .* in assignment" */
_, _ = a13, a14
a2 := [...]int{- /* ERROR "negative" */ 1: 0}
_ = a2
a3 := [...]int{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
assert(len(a3) == 5) // somewhat arbitrary
a4 := [...]complex128{0, 1, 2, 1<<10-2: -1i, 1i, 400: 10, 12, 14}
assert(len(a4) == 1024)
// composite literal element types may be elided
type T []int
_ = [10]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
a6 := [...]T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
assert(len(a6) == 8)
// recursively so
_ = [10][10]T{{}, [10]T{{}}, {{1, 2, 3}}}
// from the spec
type Point struct { x, y float32 }
_ = [...]Point{Point{1.5, -3.5}, Point{0, 0}}
_ = [...]Point{{1.5, -3.5}, {0, 0}}
_ = [][]int{[]int{1, 2, 3}, []int{4, 5}}
_ = [][]int{{1, 2, 3}, {4, 5}}
_ = [...]*Point{&Point{1.5, -3.5}, &Point{0, 0}}
_ = [...]*Point{{1.5, -3.5}, {0, 0}}
}
func slice_literals() {
type S0 []int
_ = S0{}
_ = S0{0, 1, 2}
_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
_ = S0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
_ = S0{- /* ERROR "negative" */ 1: 0}
_ = S0{8: 8, 9}
_ = S0{8: 8, 9, 10}
_ = S0{0, 1, 2, 0 /* ERROR "duplicate index" */ : 0, 3: 3, 4}
_ = S0{5: 5, 6, 7, 3: 3, 4}
_ = S0{5: 5, 6, 7, 3: 3, 4, 5 /* ERROR "duplicate index" */ }
_ = S0{10: 10, 10 /* ERROR "duplicate index" */ : 10}
_ = S0{5: 5, 6, 7, 3: 3, 1 /* ERROR "overflows" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "overflows" */ <<100: 4}
_ = S0{2.0}
_ = S0{2.1 /* ERROR "truncated" */ }
_ = S0{"foo" /* ERROR "cannot convert" */ }
// indices must be resolved correctly
const index1 = 1
_ = S0{index1: 1}
_ = S0{index2: 2}
_ = S0{index3 /* ERROR "undeclared name" */ : 3}
// indices must be integer constants
i := 1
const f = 2.1
const s = "foo"
_ = S0{i /* ERROR "index i must be integer constant" */ : 0}
_ = S0{f /* ERROR "truncated" */ : 0}
_ = S0{s /* ERROR "cannot convert" */ : 0}
// composite literal element types may be elided
type T []int
_ = []T{T{}, {}, 5: T{1, 2, 3}, 7: {1, 2, 3}}
_ = [][]int{{1, 2, 3}, {4, 5}}
// recursively so
_ = [][]T{{}, []T{{}}, {{1, 2, 3}}}
// issue 17954
type T0 *struct { s string }
_ = []T0{{}}
_ = []T0{{"foo"}}
type T1 *struct{ int }
_ = []T1{}
_ = []T1{{0}, {1}, {2}}
type T2 T1
_ = []T2{}
_ = []T2{{0}, {1}, {2}}
_ = map[T0]T2{}
_ = map[T0]T2{{}: {}}
}
const index2 int = 2
type N int
func (N) f() {}
func map_literals() {
type M0 map[string]int
type M1 map[bool]int
type M2 map[*int]int
_ = M0{}
_ = M0{1 /* ERROR "missing key" */ }
_ = M0{1 /* ERROR "cannot convert" */ : 2}
_ = M0{"foo": "bar" /* ERROR "cannot convert" */ }
_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }
_ = map[interface{}]int{2: 1, 2 /* ERROR "duplicate key" */ : 1}
_ = map[interface{}]int{int(2): 1, int16(2): 1}
_ = map[interface{}]int{int16(2): 1, int16 /* ERROR "duplicate key" */ (2): 1}
type S string
_ = map[interface{}]int{"a": 1, "a" /* ERROR "duplicate key" */ : 1}
_ = map[interface{}]int{"a": 1, S("a"): 1}
_ = map[interface{}]int{S("a"): 1, S /* ERROR "duplicate key" */ ("a"): 1}
_ = map[interface{}]int{1.0: 1, 1.0 /* ERROR "duplicate key" */: 1}
_ = map[interface{}]int{int64(-1): 1, int64 /* ERROR "duplicate key" */ (-1) : 1}
_ = map[interface{}]int{^uint64(0): 1, ^ /* ERROR "duplicate key" */ uint64(0): 1}
_ = map[interface{}]int{complex(1,2): 1, complex /* ERROR "duplicate key" */ (1,2) : 1}
type I interface {
f()
}
_ = map[I]int{N(0): 1, N(2): 1}
_ = map[I]int{N(2): 1, N /* ERROR "duplicate key" */ (2): 1}
// map keys must be resolved correctly
key1 := "foo"
_ = M0{key1: 1}
_ = M0{key2: 2}
_ = M0{key3 /* ERROR "undeclared name" */ : 2}
var value int
_ = M1{true: 1, false: 0}
_ = M2{nil: 0, &value: 1}
// composite literal element types may be elided
type T [2]int
_ = map[int]T{0: T{3, 4}, 1: {5, 6}}
// recursively so
_ = map[int][]T{0: {}, 1: {{}, T{1, 2}}}
// composite literal key types may be elided
_ = map[T]int{T{3, 4}: 0, {5, 6}: 1}
// recursively so
_ = map[[2]T]int{{}: 0, {{}}: 1, [2]T{{}}: 2, {T{1, 2}}: 3}
// composite literal element and key types may be elided
_ = map[T]T{{}: {}, {1, 2}: T{3, 4}, T{4, 5}: {}}
_ = map[T]M0{{} : {}, T{1, 2}: M0{"foo": 0}, {1, 3}: {"foo": 1}}
// recursively so
_ = map[[2]T][]T{{}: {}, {{}}: {{}, T{1, 2}}, [2]T{{}}: nil, {T{1, 2}}: {{}, {}}}
// from the spec
type Point struct { x, y float32 }
_ = map[string]Point{"orig": {0, 0}}
_ = map[*Point]string{{0, 0}: "orig"}
// issue 17954
type T0 *struct{ s string }
type T1 *struct{ int }
type T2 T1
_ = map[T0]T2{}
_ = map[T0]T2{{}: {}}
}
var key2 string = "bar"
type I interface {
m()
}
type I2 interface {
m(int)
}
type T1 struct{}
type T2 struct{}
func (T2) m(int) {}
type mybool bool
func type_asserts() {
var x int
_ = x /* ERROR "not an interface" */ .(int)
var e interface{}
var ok bool
x, ok = e.(int)
_ = ok
// ok value is of type bool
var myok mybool
_, myok = e.(int)
_ = myok
var t I
_ = t /* ERROR "use of .* outside type switch" */ .(type)
_ = t /* ERROR "missing method m" */ .(T)
_ = t.(*T)
_ = t /* ERROR "missing method m" */ .(T1)
_ = t /* ERROR "wrong type for method m" */ .(T2)
_ = t /* STRICT "wrong type for method m" */ .(I2) // only an error in strict mode (issue 8561)
// e doesn't statically have an m, but may have one dynamically.
_ = e.(I2)
}
func f0() {}
func f1(x int) {}
func f2(u float32, s string) {}
func fs(s []byte) {}
func fv(x ...int) {}
func fi(x ... interface{}) {}
func (T) fm(x ...int)
func g0() {}
func g1() int { return 0}
func g2() (u float32, s string) { return }
func gs() []byte { return nil }
func _calls() {
var x int
var y float32
var s []int
f0()
_ = f0 /* ERROR "used as value" */ ()
f0(g0 /* ERROR "too many arguments" */ )
f1(0)
f1(x)
f1(10.0)
f1() /* ERROR "too few arguments" */
f1(x, y /* ERROR "too many arguments" */ )
f1(s /* ERROR "cannot use .* in argument" */ )
f1(x ... /* ERROR "cannot use ..." */ )
f1(g0 /* ERROR "used as value" */ ())
f1(g1())
f1(g2 /* ERROR "cannot use g2" */ /* ERROR "too many arguments" */ ())
f2() /* ERROR "too few arguments" */
f2(3.14) /* ERROR "too few arguments" */
f2(3.14, "foo")
f2(x /* ERROR "cannot use .* in argument" */ , "foo")
f2(g0 /* ERROR "used as value" */ ())
f2(g1 /* ERROR "cannot use .* in argument" */ ()) /* ERROR "too few arguments" */
f2(g2())
fs() /* ERROR "too few arguments" */
fs(g0 /* ERROR "used as value" */ ())
fs(g1 /* ERROR "cannot use .* in argument" */ ())
fs(g2 /* ERROR "cannot use .* in argument" */ /* ERROR "too many arguments" */ ())
fs(gs())
fv()
fv(1, 2.0, x)
fv(s /* ERROR "cannot use .* in argument" */ )
fv(s...)
fv(x /* ERROR "cannot use" */ ...)
fv(1, s... /* ERROR "can only use ... with matching parameter" */ )
fv(gs /* ERROR "cannot use .* in argument" */ ())
fv(gs /* ERROR "cannot use .* in argument" */ ()...)
var t T
t.fm()
t.fm(1, 2.0, x)
t.fm(s /* ERROR "cannot use .* in argument" */ )
t.fm(g1())
t.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
t.fm(gs /* ERROR "cannot use .* in argument" */ ())
t.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
T.fm(t, )
T.fm(t, 1, 2.0, x)
T.fm(t, s /* ERROR "cannot use .* in argument" */ )
T.fm(t, g1())
T.fm(t, 1, s... /* ERROR "can only use ... with matching parameter" */ )
T.fm(t, gs /* ERROR "cannot use .* in argument" */ ())
T.fm(t, gs /* ERROR "cannot use .* in argument" */ ()...)
var i interface{ fm(x ...int) } = t
i.fm()
i.fm(1, 2.0, x)
i.fm(s /* ERROR "cannot use .* in argument" */ )
i.fm(g1())
i.fm(1, s... /* ERROR "can only use ... with matching parameter" */ )
i.fm(gs /* ERROR "cannot use .* in argument" */ ())
i.fm(gs /* ERROR "cannot use .* in argument" */ ()...)
fi()
fi(1, 2.0, x, 3.14, "foo")
fi(g2())
fi(0, g2)
fi(0, g2 /* ERROR "2-valued g2" */ ())
}
func issue6344() {
type T []interface{}
var x T
fi(x...) // ... applies also to named slices
}

560
src/cmd/compile/internal/types2/testdata/gotos.src vendored Normal file
View file

@ -0,0 +1,560 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This file is a modified copy of $GOROOT/test/goto.go.
package gotos
var (
i, n int
x []int
c chan int
m map[int]int
s string
)
// goto after declaration okay
func _() {
x := 1
goto L
L:
_ = x
}
// goto before declaration okay
func _() {
goto L
L:
x := 1
_ = x
}
// goto across declaration not okay
func _() {
goto L /* ERROR "goto L jumps over variable declaration at line 36" */
x := 1
_ = x
L:
}
// goto across declaration in inner scope okay
func _() {
goto L
{
x := 1
_ = x
}
L:
}
// goto across declaration after inner scope not okay
func _() {
goto L /* ERROR "goto L jumps over variable declaration at line 58" */
{
x := 1
_ = x
}
x := 1
_ = x
L:
}
// goto across declaration in reverse okay
func _() {
L:
x := 1
_ = x
goto L
}
func _() {
L: L1:
x := 1
_ = x
goto L
goto L1
}
// error shows first offending variable
func _() {
goto L /* ERROR "goto L jumps over variable declaration at line 84" */
x := 1
_ = x
y := 1
_ = y
L:
}
// goto not okay even if code path is dead
func _() {
goto L /* ERROR "goto L jumps over variable declaration" */
x := 1
_ = x
y := 1
_ = y
return
L:
}
// goto into outer block okay
func _() {
{
goto L
}
L:
}
func _() {
{
goto L
goto L1
}
L: L1:
}
// goto backward into outer block okay
func _() {
L:
{
goto L
}
}
func _() {
L: L1:
{
goto L
goto L1
}
}
// goto into inner block not okay
func _() {
goto L /* ERROR "goto L jumps into block" */
{
L:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
goto L1 /* ERROR "goto L1 jumps into block" */
{
L: L1:
}
}
// goto backward into inner block still not okay
func _() {
{
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
{
L: L1:
}
goto L /* ERROR "goto L jumps into block" */
goto L1 /* ERROR "goto L1 jumps into block" */
}
// error shows first (outermost) offending block
func _() {
goto L /* ERROR "goto L jumps into block" */
{
{
{
L:
}
}
}
}
// error prefers block diagnostic over declaration diagnostic
func _() {
goto L /* ERROR "goto L jumps into block" */
x := 1
_ = x
{
L:
}
}
// many kinds of blocks, all invalid to jump into or among,
// but valid to jump out of
// if
func _() {
L:
if true {
goto L
}
}
func _() {
L:
if true {
goto L
} else {
}
}
func _() {
L:
if false {
} else {
goto L
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
if true {
L:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
if true {
L:
} else {
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
if true {
} else {
L:
}
}
func _() {
if false {
L:
} else {
goto L /* ERROR "goto L jumps into block" */
}
}
func _() {
if true {
goto L /* ERROR "goto L jumps into block" */
} else {
L:
}
}
func _() {
if true {
goto L /* ERROR "goto L jumps into block" */
} else if false {
L:
}
}
func _() {
if true {
goto L /* ERROR "goto L jumps into block" */
} else if false {
L:
} else {
}
}
func _() {
if true {
goto L /* ERROR "goto L jumps into block" */
} else if false {
} else {
L:
}
}
func _() {
if true {
goto L /* ERROR "goto L jumps into block" */
} else {
L:
}
}
func _() {
if true {
L:
} else {
goto L /* ERROR "goto L jumps into block" */
}
}
// for
func _() {
for {
goto L
}
L:
}
func _() {
for {
goto L
L:
}
}
func _() {
for {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
for {
goto L
L1:
}
L:
goto L1 /* ERROR "goto L1 jumps into block" */
}
func _() {
for i < n {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
for i = 0; i < n; i++ {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
for i = range x {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
for i = range c {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
for i = range m {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
func _() {
for i = range s {
L:
}
goto L /* ERROR "goto L jumps into block" */
}
// switch
func _() {
L:
switch i {
case 0:
goto L
}
}
func _() {
L:
switch i {
case 0:
default:
goto L
}
}
func _() {
switch i {
case 0:
default:
L:
goto L
}
}
func _() {
switch i {
case 0:
default:
goto L
L:
}
}
func _() {
switch i {
case 0:
goto L
L:
;
default:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
switch i {
case 0:
L:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
switch i {
case 0:
L:
;
default:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
switch i {
case 0:
default:
L:
}
}
func _() {
switch i {
default:
goto L /* ERROR "goto L jumps into block" */
case 0:
L:
}
}
func _() {
switch i {
case 0:
L:
;
default:
goto L /* ERROR "goto L jumps into block" */
}
}
// select
// different from switch. the statement has no implicit block around it.
func _() {
L:
select {
case <-c:
goto L
}
}
func _() {
L:
select {
case c <- 1:
default:
goto L
}
}
func _() {
select {
case <-c:
default:
L:
goto L
}
}
func _() {
select {
case c <- 1:
default:
goto L
L:
}
}
func _() {
select {
case <-c:
goto L
L:
;
default:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
select {
case c <- 1:
L:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
select {
case c <- 1:
L:
;
default:
}
}
func _() {
goto L /* ERROR "goto L jumps into block" */
select {
case <-c:
default:
L:
}
}
func _() {
select {
default:
goto L /* ERROR "goto L jumps into block" */
case <-c:
L:
}
}
func _() {
select {
case <-c:
L:
;
default:
goto L /* ERROR "goto L jumps into block" */
}
}

54
src/cmd/compile/internal/types2/testdata/importC.src vendored Normal file
View file

@ -0,0 +1,54 @@
// Copyright 2015 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 importC
import "C"
import _ /* ERROR cannot rename import "C" */ "C"
import foo /* ERROR cannot rename import "C" */ "C"
import . /* ERROR cannot rename import "C" */ "C"
// Test cases extracted from issue #22090.
import "unsafe"
const _ C.int = 0xff // no error due to invalid constant type
type T struct {
Name string
Ordinal int
}
func _(args []T) {
var s string
for i, v := range args {
cname := C.CString(v.Name)
args[i].Ordinal = int(C.sqlite3_bind_parameter_index(s, cname)) // no error due to i not being "used"
C.free(unsafe.Pointer(cname))
}
}
type CType C.Type
const _ CType = C.X // no error due to invalid constant type
const _ = C.X
// Test cases extracted from issue #23712.
func _() {
var a [C.ArrayLength]byte
_ = a[0] // no index out of bounds error here
}
// Additional tests to verify fix for #23712.
func _() {
var a [C.ArrayLength1]byte
_ = 1 / len(a) // no division by zero error here and below
_ = 1 / cap(a)
_ = uint(unsafe.Sizeof(a)) // must not be negative
var b [C.ArrayLength2]byte
a = b // should be valid
}

106
src/cmd/compile/internal/types2/testdata/init0.src vendored Normal file
View file

@ -0,0 +1,106 @@
// 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.
// initialization cycles
package init0
// initialization cycles (we don't know the types)
const (
s0 /* ERROR initialization cycle */ = s0
x0 /* ERROR initialization cycle */ = y0
y0 = x0
a0 = b0
b0 /* ERROR initialization cycle */ = c0
c0 = d0
d0 = b0
)
var (
s1 /* ERROR initialization cycle */ = s1
x1 /* ERROR initialization cycle */ = y1
y1 = x1
a1 = b1
b1 /* ERROR initialization cycle */ = c1
c1 = d1
d1 = b1
)
// initialization cycles (we know the types)
const (
s2 /* ERROR initialization cycle */ int = s2
x2 /* ERROR initialization cycle */ int = y2
y2 = x2
a2 = b2
b2 /* ERROR initialization cycle */ int = c2
c2 = d2
d2 = b2
)
var (
s3 /* ERROR initialization cycle */ int = s3
x3 /* ERROR initialization cycle */ int = y3
y3 = x3
a3 = b3
b3 /* ERROR initialization cycle */ int = c3
c3 = d3
d3 = b3
)
// cycles via struct fields
type S1 struct {
f int
}
const cx3 S1 /* ERROR invalid constant type */ = S1{cx3.f}
var vx3 /* ERROR initialization cycle */ S1 = S1{vx3.f}
// cycles via functions
var x4 = x5
var x5 /* ERROR initialization cycle */ = f1()
func f1() int { return x5*10 }
var x6, x7 /* ERROR initialization cycle */ = f2()
var x8 = x7
func f2() (int, int) { return f3() + f3(), 0 }
func f3() int { return x8 }
// cycles via function literals
var x9 /* ERROR initialization cycle */ = func() int { return x9 }()
var x10 /* ERROR initialization cycle */ = f4()
func f4() int {
_ = func() {
_ = x10
}
return 0
}
// cycles via method expressions
type T1 struct{}
func (T1) m() bool { _ = x11; return false }
var x11 /* ERROR initialization cycle */ = T1.m(T1{})
// cycles via method values
type T2 struct{}
func (T2) m() bool { _ = x12; return false }
var t1 T2
var x12 /* ERROR initialization cycle */ = t1.m

97
src/cmd/compile/internal/types2/testdata/init1.src vendored Normal file
View file

@ -0,0 +1,97 @@
// 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.
// initialization cycles
package init1
// issue 6683 (marked as WorkingAsIntended)
type T0 struct{}
func (T0) m() int { return y0 }
var x0 = T0{}
var y0 /* ERROR initialization cycle */ = x0.m()
type T1 struct{}
func (T1) m() int { return y1 }
var x1 interface {
m() int
} = T1{}
var y1 = x1.m() // no cycle reported, x1 is of interface type
// issue 6703 (modified)
var x2 /* ERROR initialization cycle */ = T2.m
var y2 = x2
type T2 struct{}
func (T2) m() int {
_ = y2
return 0
}
var x3 /* ERROR initialization cycle */ = T3.m(T3{}) // <<<< added (T3{})
var y3 = x3
type T3 struct{}
func (T3) m() int {
_ = y3
return 0
}
var x4 /* ERROR initialization cycle */ = T4{}.m // <<<< added {}
var y4 = x4
type T4 struct{}
func (T4) m() int {
_ = y4
return 0
}
var x5 /* ERROR initialization cycle */ = T5{}.m() // <<<< added ()
var y5 = x5
type T5 struct{}
func (T5) m() int {
_ = y5
return 0
}
// issue 4847
// simplified test case
var x6 = f6
var y6 /* ERROR initialization cycle */ = f6
func f6() { _ = y6 }
// full test case
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 /* ERROR initialization cycle */ = matcher(matchList)
func matchAnyFn(s *S) (err E) { return matchAny(s) }

139
src/cmd/compile/internal/types2/testdata/init2.src vendored Normal file
View file

@ -0,0 +1,139 @@
// Copyright 2014 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.
// initialization cycles
package init2
// cycles through functions
func f1() int { _ = x1; return 0 }
var x1 /* ERROR initialization cycle */ = f1
func f2() int { _ = x2; return 0 }
var x2 /* ERROR initialization cycle */ = f2()
// cycles through method expressions
type T3 int
func (T3) m() int { _ = x3; return 0 }
var x3 /* ERROR initialization cycle */ = T3.m
type T4 int
func (T4) m() int { _ = x4; return 0 }
var x4 /* ERROR initialization cycle */ = T4.m(0)
type T3p int
func (*T3p) m() int { _ = x3p; return 0 }
var x3p /* ERROR initialization cycle */ = (*T3p).m
type T4p int
func (*T4p) m() int { _ = x4p; return 0 }
var x4p /* ERROR initialization cycle */ = (*T4p).m(nil)
// cycles through method expressions of embedded methods
type T5 struct { E5 }
type E5 int
func (E5) m() int { _ = x5; return 0 }
var x5 /* ERROR initialization cycle */ = T5.m
type T6 struct { E6 }
type E6 int
func (E6) m() int { _ = x6; return 0 }
var x6 /* ERROR initialization cycle */ = T6.m(T6{0})
type T5p struct { E5p }
type E5p int
func (*E5p) m() int { _ = x5p; return 0 }
var x5p /* ERROR initialization cycle */ = (*T5p).m
type T6p struct { E6p }
type E6p int
func (*E6p) m() int { _ = x6p; return 0 }
var x6p /* ERROR initialization cycle */ = (*T6p).m(nil)
// cycles through method values
type T7 int
func (T7) m() int { _ = x7; return 0 }
var x7 /* ERROR initialization cycle */ = T7(0).m
type T8 int
func (T8) m() int { _ = x8; return 0 }
var x8 /* ERROR initialization cycle */ = T8(0).m()
type T7p int
func (*T7p) m() int { _ = x7p; return 0 }
var x7p /* ERROR initialization cycle */ = new(T7p).m
type T8p int
func (*T8p) m() int { _ = x8p; return 0 }
var x8p /* ERROR initialization cycle */ = new(T8p).m()
type T7v int
func (T7v) m() int { _ = x7v; return 0 }
var x7var T7v
var x7v /* ERROR initialization cycle */ = x7var.m
type T8v int
func (T8v) m() int { _ = x8v; return 0 }
var x8var T8v
var x8v /* ERROR initialization cycle */ = x8var.m()
type T7pv int
func (*T7pv) m() int { _ = x7pv; return 0 }
var x7pvar *T7pv
var x7pv /* ERROR initialization cycle */ = x7pvar.m
type T8pv int
func (*T8pv) m() int { _ = x8pv; return 0 }
var x8pvar *T8pv
var x8pv /* ERROR initialization cycle */ = x8pvar.m()
// cycles through method values of embedded methods
type T9 struct { E9 }
type E9 int
func (E9) m() int { _ = x9; return 0 }
var x9 /* ERROR initialization cycle */ = T9{0}.m
type T10 struct { E10 }
type E10 int
func (E10) m() int { _ = x10; return 0 }
var x10 /* ERROR initialization cycle */ = T10{0}.m()
type T9p struct { E9p }
type E9p int
func (*E9p) m() int { _ = x9p; return 0 }
var x9p /* ERROR initialization cycle */ = new(T9p).m
type T10p struct { E10p }
type E10p int
func (*E10p) m() int { _ = x10p; return 0 }
var x10p /* ERROR initialization cycle */ = new(T10p).m()
type T9v struct { E9v }
type E9v int
func (E9v) m() int { _ = x9v; return 0 }
var x9var T9v
var x9v /* ERROR initialization cycle */ = x9var.m
type T10v struct { E10v }
type E10v int
func (E10v) m() int { _ = x10v; return 0 }
var x10var T10v
var x10v /* ERROR initialization cycle */ = x10var.m()
type T9pv struct { E9pv }
type E9pv int
func (*E9pv) m() int { _ = x9pv; return 0 }
var x9pvar *T9pv
var x9pv /* ERROR initialization cycle */ = x9pvar.m
type T10pv struct { E10pv }
type E10pv int
func (*E10pv) m() int { _ = x10pv; return 0 }
var x10pvar *T10pv
var x10pv /* ERROR initialization cycle */ = x10pvar.m()

365
src/cmd/compile/internal/types2/testdata/issues.src vendored Normal file
View file

@ -0,0 +1,365 @@
// Copyright 2014 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 issues
import (
"fmt"
syn "cmd/compile/internal/syntax"
t1 "text/template"
t2 "html/template"
)
func issue7035() {
type T struct{ X int }
_ = func() {
fmt.Println() // must refer to imported fmt rather than the fmt below
}
fmt := new(T)
_ = fmt.X
}
func issue8066() {
const (
_ = float32(340282356779733661637539395458142568447)
_ = float32(340282356779733661637539395458142568448 /* ERROR cannot convert */ )
)
}
// Check that a missing identifier doesn't lead to a spurious error cascade.
func issue8799a() {
x, ok := missing /* ERROR undeclared */ ()
_ = !ok
_ = x
}
func issue8799b(x int, ok bool) {
x, ok = missing /* ERROR undeclared */ ()
_ = !ok
_ = x
}
func issue9182() {
type Point C /* ERROR undeclared */ .Point
// no error for composite literal based on unknown type
_ = Point{x: 1, y: 2}
}
func f0() (a []int) { return }
func f1() (a []int, b int) { return }
func f2() (a, b []int) { return }
func append_([]int, ...int) {}
func issue9473(a []int, b ...int) {
// variadic builtin function
_ = append(f0())
_ = append(f0(), f0()...)
_ = append(f1())
_ = append(f2 /* ERROR cannot use .* in argument */ ())
_ = append(f2()... /* ERROR cannot use ... */ )
_ = append(f0(), f1 /* ERROR 2-valued f1 */ ())
_ = append(f0(), f2 /* ERROR 2-valued f2 */ ())
_ = append(f0(), f1 /* ERROR 2-valued f1 */ ()...)
_ = append(f0(), f2 /* ERROR 2-valued f2 */ ()...)
// variadic user-defined function
append_(f0())
append_(f0(), f0()...)
append_(f1())
append_(f2 /* ERROR cannot use .* in argument */ ())
append_(f2()... /* ERROR cannot use ... */ )
append_(f0(), f1 /* ERROR 2-valued f1 */ ())
append_(f0(), f2 /* ERROR 2-valued f2 */ ())
append_(f0(), f1 /* ERROR 2-valued f1 */ ()...)
append_(f0(), f2 /* ERROR 2-valued f2 */ ()...)
}
// Check that embedding a non-interface type in an interface results in a good error message.
func issue10979() {
type _ interface {
int /* ERROR int is not an interface */
}
type T struct{}
type _ interface {
T /* ERROR T is not an interface */
}
type _ interface {
nosuchtype /* ERROR undeclared name: nosuchtype */
}
type _ interface {
fmt.Nosuchtype /* ERROR Nosuchtype not declared by package fmt */
}
type _ interface {
nosuchpkg /* ERROR undeclared name: nosuchpkg */ .Nosuchtype
}
type I interface {
I.m /* ERROR no field or method m */
m()
}
}
// issue11347
// These should not crash.
var a1, b1 /* ERROR cycle */ , c1 /* ERROR cycle */ b1 = 0 > 0<<""[""[c1]]>c1
var a2, b2 /* ERROR cycle */ = 0 /* ERROR cannot initialize */ /* ERROR cannot initialize */ > 0<<""[b2]
var a3, b3 /* ERROR cycle */ = int /* ERROR cannot initialize */ /* ERROR cannot initialize */ (1<<""[b3])
// issue10260
// Check that error messages explain reason for interface assignment failures.
type (
I0 interface{}
I1 interface{ foo() }
I2 interface{ foo(x int) }
T0 struct{}
T1 struct{}
T2 struct{}
)
func (*T1) foo() {}
func (*T2) foo(x int) {}
func issue10260() {
var (
i0 I0
i1 I1
i2 I2
t0 *T0
t1 *T1
t2 *T2
)
var x I1
x = T1 /* ERROR cannot use .*: missing method foo \(foo has pointer receiver\) */ {}
_ = x /* ERROR .* cannot have dynamic type T1 \(missing method foo \(foo has pointer receiver\)\) */ .(T1)
T1{}.foo /* ERROR cannot call pointer method foo on T1 */ ()
x.Foo /* ERROR "x.Foo undefined \(type I1 has no field or method Foo, but does have foo\)" */ ()
_ = i2 /* ERROR i2 .* cannot have dynamic type \*T1 \(wrong type for method foo \(have func\(\), want func\(x int\)\)\) */ .(*T1)
i1 = i0 /* ERROR cannot use .* missing method foo */
i1 = t0 /* ERROR cannot use .* missing method foo */
i1 = i2 /* ERROR cannot use .* wrong type for method foo */
i1 = t2 /* ERROR cannot use .* wrong type for method foo */
i2 = i1 /* ERROR cannot use .* wrong type for method foo */
i2 = t1 /* ERROR cannot use .* wrong type for method foo */
_ = func() I1 { return i0 /* ERROR cannot use .* missing method foo */ }
_ = func() I1 { return t0 /* ERROR cannot use .* missing method foo */ }
_ = func() I1 { return i2 /* ERROR cannot use .* wrong type for method foo */ }
_ = func() I1 { return t2 /* ERROR cannot use .* wrong type for method foo */ }
_ = func() I2 { return i1 /* ERROR cannot use .* wrong type for method foo */ }
_ = func() I2 { return t1 /* ERROR cannot use .* wrong type for method foo */ }
// a few more - less exhaustive now
f := func(I1, I2){}
f(i0 /* ERROR cannot use .* missing method foo */ , i1 /* ERROR cannot use .* wrong type for method foo \(have func\(\), want func\(x int\)\) */ )
_ = [...]I1{i0 /* ERROR cannot use .* missing method foo */ }
_ = [...]I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
_ = []I1{i0 /* ERROR cannot use .* missing method foo */ }
_ = []I1{i2 /* ERROR cannot use .* wrong type for method foo */ }
_ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ }
_ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ }
make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
}
// Check that constants representable as integers are in integer form
// before being used in operations that are only defined on integers.
func issue14229() {
// from the issue
const _ = int64(-1<<63) % 1e6
// related
const (
a int = 3
b = 4.0
_ = a / b
_ = a % b
_ = b / a
_ = b % a
)
}
// Check that in a n:1 variable declaration with type and initialization
// expression the type is distributed to all variables of the lhs before
// the initialization expression assignment is checked.
func issue15755() {
// from issue
var i interface{}
type b bool
var x, y b = i.(b)
_ = x == y
// related: we should see an error since the result of f1 is ([]int, int)
var u, v []int = f1 /* ERROR cannot use f1 */ ()
_ = u
_ = v
}
// Test that we don't get "declared but not used"
// errors in the context of invalid/C objects.
func issue20358() {
var F C /* ERROR "undeclared" */ .F
var A C /* ERROR "undeclared" */ .A
var S C /* ERROR "undeclared" */ .S
type T C /* ERROR "undeclared" */ .T
type P C /* ERROR "undeclared" */ .P
// these variables must be "used" even though
// the LHS expressions/types below in which
// context they are used are unknown/invalid
var f, a, s1, s2, s3, t, p int
_ = F(f)
_ = A[a]
_ = S[s1:s2:s3]
_ = T{t}
_ = P{f: p}
}
// Test that we don't declare lhs variables in short variable
// declarations before we type-check function literals on the
// rhs.
func issue24026() {
f := func() int { f(0) /* must refer to outer f */; return 0 }
_ = f
_ = func() {
f := func() { _ = f() /* must refer to outer f */ }
_ = f
}
// b and c must not be visible inside function literal
a := 0
a, b, c := func() (int, int, int) {
return a, b /* ERROR undeclared */ , c /* ERROR undeclared */
}()
_, _ = b, c
}
func f(int) {} // for issue24026
// Test that we don't report a "missing return statement" error
// (due to incorrect context when type-checking interfaces).
func issue24140(x interface{}) int {
switch x.(type) {
case interface{}:
return 0
default:
panic(0)
}
}
// Test that we don't crash when the 'if' condition is missing.
func issue25438() {
if { /* ERROR missing condition */ }
if x := 0; /* ERROR missing condition */ { _ = x }
if
{ /* ERROR missing condition */ }
}
// Test that we can embed alias type names in interfaces.
type issue25301 interface {
E
}
type E = interface {
m()
}
// Test case from issue.
// cmd/compile reports a cycle as well.
type issue25301b /* ERROR cycle */ = interface {
m() interface{ issue25301b }
}
type issue25301c interface {
notE // ERROR struct\{\} is not an interface
}
type notE = struct{}
// Test that method declarations don't introduce artificial cycles
// (issue #26124).
const CC TT = 1
type TT int
func (TT) MM() [CC]TT
// Reduced test case from issue #26124.
const preloadLimit LNumber = 128
type LNumber float64
func (LNumber) assertFunction() *LFunction
type LFunction struct {
GFunction LGFunction
}
type LGFunction func(*LState)
type LState struct {
reg *registry
}
type registry struct {
alloc *allocator
}
type allocator struct {
_ [int(preloadLimit)]int
}
// Test that we don't crash when type-checking composite literals
// containing errors in the type.
var issue27346 = [][n /* ERROR undeclared */ ]int{
0: {},
}
var issue22467 = map[int][... /* ERROR invalid use of ... */ ]int{0: {}}
// Test that invalid use of ... in parameter lists is recognized
// (issue #28281).
func issue28281a(int, int, ...int)
func issue28281b(a, b int, c ...int)
func issue28281c(a, b, c ... /* ERROR can only use ... with final parameter */ int)
func issue28281d(... /* ERROR can only use ... with final parameter */ int, int)
func issue28281e(a, b, c ... /* ERROR can only use ... with final parameter */ int, d int)
func issue28281f(... /* ERROR can only use ... with final parameter */ int, ... /* ERROR can only use ... with final parameter */ int, int)
func (... /* ERROR expected type */ TT) f()
func issue28281g() (... /* ERROR expected type */ TT)
// Issue #26234: Make various field/method lookup errors easier to read by matching cmd/compile's output
func issue26234a(f *syn.File) {
// The error message below should refer to the actual package name (syntax)
// not the local package name (syn).
f.foo /* ERROR f.foo undefined \(type \*syntax.File has no field or method foo\) */
}
type T struct {
x int
E1
E2
}
type E1 struct{ f int }
type E2 struct{ f int }
func issue26234b(x T) {
_ = x.f /* ERROR ambiguous selector x.f */
}
func issue26234c() {
T.x /* ERROR T.x undefined \(type T has no method x\) */ ()
}
func issue35895() {
// T is defined in this package, don't qualify its name with the package name.
var _ T = 0 // ERROR cannot convert 0 \(untyped int constant\) to T
// There is only one package with name syntax imported, only use the (global) package name in error messages.
var _ *syn.File = 0 // ERROR cannot convert 0 \(untyped int constant\) to \*syntax.File
// Because both t1 and t2 have the same global package name (template),
// qualify packages with full path name in this case.
var _ t1.Template = t2 /* ERROR cannot use .* \(value of type "html/template".Template\) as "text/template".Template */ .Template{}
}

207
src/cmd/compile/internal/types2/testdata/labels.src vendored Normal file
View file

@ -0,0 +1,207 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This file is a modified concatenation of the files
// $GOROOT/test/label.go and $GOROOT/test/label1.go.
package labels
var x int
func f0() {
L1 /* ERROR "label L1 declared but not used" */ :
for {
}
L2 /* ERROR "label L2 declared but not used" */ :
select {
}
L3 /* ERROR "label L3 declared but not used" */ :
switch {
}
L4 /* ERROR "label L4 declared but not used" */ :
if true {
}
L5 /* ERROR "label L5 declared but not used" */ :
f0()
L6:
f0()
L6 /* ERROR "label L6 already declared" */ :
f0()
if x == 20 {
goto L6
}
L7:
for {
break L7
break L8 /* ERROR "invalid break label L8" */
}
// A label must be directly associated with a switch, select, or
// for statement; it cannot be the label of a labeled statement.
L7a /* ERROR "declared but not used" */ : L7b:
for {
break L7a /* ERROR "invalid break label L7a" */
continue L7a /* ERROR "invalid continue label L7a" */
continue L7b
}
L8:
for {
if x == 21 {
continue L8
continue L7 /* ERROR "invalid continue label L7" */
}
}
L9:
switch {
case true:
break L9
defalt /* ERROR "label defalt declared but not used" */ :
}
L10:
select {
default:
break L10
break L9 /* ERROR "invalid break label L9" */
}
goto L10a
L10a: L10b:
select {
default:
break L10a /* ERROR "invalid break label L10a" */
break L10b
continue L10b /* ERROR "invalid continue label L10b" */
}
}
func f1() {
L1:
for {
if x == 0 {
break L1
}
if x == 1 {
continue L1
}
goto L1
}
L2:
select {
default:
if x == 0 {
break L2
}
if x == 1 {
continue L2 /* ERROR "invalid continue label L2" */
}
goto L2
}
L3:
switch {
case x > 10:
if x == 11 {
break L3
}
if x == 12 {
continue L3 /* ERROR "invalid continue label L3" */
}
goto L3
}
L4:
if true {
if x == 13 {
break L4 /* ERROR "invalid break label L4" */
}
if x == 14 {
continue L4 /* ERROR "invalid continue label L4" */
}
if x == 15 {
goto L4
}
}
L5:
f1()
if x == 16 {
break L5 /* ERROR "invalid break label L5" */
}
if x == 17 {
continue L5 /* ERROR "invalid continue label L5" */
}
if x == 18 {
goto L5
}
for {
if x == 19 {
break L1 /* ERROR "invalid break label L1" */
}
if x == 20 {
continue L1 /* ERROR "invalid continue label L1" */
}
if x == 21 {
goto L1
}
}
}
// Additional tests not in the original files.
func f2() {
L1 /* ERROR "label L1 declared but not used" */ :
if x == 0 {
for {
continue L1 /* ERROR "invalid continue label L1" */
}
}
}
func f3() {
L1:
L2:
L3:
for {
break L1 /* ERROR "invalid break label L1" */
break L2 /* ERROR "invalid break label L2" */
break L3
continue L1 /* ERROR "invalid continue label L1" */
continue L2 /* ERROR "invalid continue label L2" */
continue L3
goto L1
goto L2
goto L3
}
}
// Blank labels are never declared.
func f4() {
_:
_: // multiple blank labels are ok
goto _ /* ERROR "label _ not declared" */
}
func f5() {
_:
for {
break _ /* ERROR "invalid break label _" */
continue _ /* ERROR "invalid continue label _" */
}
}
func f6() {
_:
switch {
default:
break _ /* ERROR "invalid break label _" */
}
}

111
src/cmd/compile/internal/types2/testdata/literals.src vendored Normal file
View file

@ -0,0 +1,111 @@
// Copyright 2019 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.
// This file tests various representations of literals
// and compares them with literals or constant expressions
// of equal values.
package literals
func _() {
// 0-octals
assert(0_123 == 0123)
assert(0123_456 == 0123456)
// decimals
assert(1_234 == 1234)
assert(1_234_567 == 1234567)
// hexadecimals
assert(0X_0 == 0)
assert(0X_1234 == 0x1234)
assert(0X_CAFE_f00d == 0xcafef00d)
// octals
assert(0o0 == 0)
assert(0o1234 == 01234)
assert(0o01234567 == 01234567)
assert(0O0 == 0)
assert(0O1234 == 01234)
assert(0O01234567 == 01234567)
assert(0o_0 == 0)
assert(0o_1234 == 01234)
assert(0o0123_4567 == 01234567)
assert(0O_0 == 0)
assert(0O_1234 == 01234)
assert(0O0123_4567 == 01234567)
// binaries
assert(0b0 == 0)
assert(0b1011 == 0xb)
assert(0b00101101 == 0x2d)
assert(0B0 == 0)
assert(0B1011 == 0xb)
assert(0B00101101 == 0x2d)
assert(0b_0 == 0)
assert(0b10_11 == 0xb)
assert(0b_0010_1101 == 0x2d)
// decimal floats
assert(1_2_3. == 123.)
assert(0_123. == 123.)
assert(0_0e0 == 0.)
assert(1_2_3e0 == 123.)
assert(0_123e0 == 123.)
assert(0e-0_0 == 0.)
assert(1_2_3E+0 == 123.)
assert(0123E1_2_3 == 123e123)
assert(0.e+1 == 0.)
assert(123.E-1_0 == 123e-10)
assert(01_23.e123 == 123e123)
assert(.0e-1 == .0)
assert(.123E+10 == .123e10)
assert(.0123E123 == .0123e123)
assert(1_2_3.123 == 123.123)
assert(0123.01_23 == 123.0123)
// hexadecimal floats
assert(0x0.p+0 == 0.)
assert(0Xdeadcafe.p-10 == 0xdeadcafe/1024.0)
assert(0x1234.P84 == 0x1234000000000000000000000)
assert(0x.1p-0 == 1./16)
assert(0X.deadcafep4 == 1.0*0xdeadcafe/0x10000000)
assert(0x.1234P+12 == 1.0*0x1234/0x10)
assert(0x0p0 == 0.)
assert(0Xdeadcafep+1 == 0x1bd5b95fc)
assert(0x1234P-10 == 0x1234/1024.0)
assert(0x0.0p0 == 0.)
assert(0Xdead.cafep+1 == 1.0*0x1bd5b95fc/0x10000)
assert(0x12.34P-10 == 1.0*0x1234/0x40000)
assert(0Xdead_cafep+1 == 0xdeadcafep+1)
assert(0x_1234P-10 == 0x1234p-10)
assert(0X_dead_cafe.p-10 == 0xdeadcafe.p-10)
assert(0x12_34.P1_2_3 == 0x1234.p123)
assert(1_234i == 1234i)
assert(1_234_567i == 1234567i)
assert(0.i == 0i)
assert(123.i == 123i)
assert(0123.i == 123i)
assert(0.e+1i == 0i)
assert(123.E-1_0i == 123e-10i)
assert(01_23.e123i == 123e123i)
}

214
src/cmd/compile/internal/types2/testdata/methodsets.src vendored Normal file
View file

@ -0,0 +1,214 @@
// 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 methodsets
type T0 struct {}
func (T0) v0() {}
func (*T0) p0() {}
type T1 struct {} // like T0 with different method names
func (T1) v1() {}
func (*T1) p1() {}
type T2 interface {
v2()
p2()
}
type T3 struct {
T0
*T1
T2
}
// Method expressions
func _() {
var (
_ func(T0) = T0.v0
_ = T0.p0 /* ERROR "cannot call pointer method p0 on T0" */
_ func (*T0) = (*T0).v0
_ func (*T0) = (*T0).p0
// T1 is like T0
_ func(T2) = T2.v2
_ func(T2) = T2.p2
_ func(T3) = T3.v0
_ func(T3) = T3.p0 /* ERROR "cannot call pointer method p0 on T3" */
_ func(T3) = T3.v1
_ func(T3) = T3.p1
_ func(T3) = T3.v2
_ func(T3) = T3.p2
_ func(*T3) = (*T3).v0
_ func(*T3) = (*T3).p0
_ func(*T3) = (*T3).v1
_ func(*T3) = (*T3).p1
_ func(*T3) = (*T3).v2
_ func(*T3) = (*T3).p2
)
}
// Method values with addressable receivers
func _() {
var (
v0 T0
_ func() = v0.v0
_ func() = v0.p0
)
var (
p0 *T0
_ func() = p0.v0
_ func() = p0.p0
)
// T1 is like T0
var (
v2 T2
_ func() = v2.v2
_ func() = v2.p2
)
var (
v4 T3
_ func() = v4.v0
_ func() = v4.p0
_ func() = v4.v1
_ func() = v4.p1
_ func() = v4.v2
_ func() = v4.p2
)
var (
p4 *T3
_ func() = p4.v0
_ func() = p4.p0
_ func() = p4.v1
_ func() = p4.p1
_ func() = p4.v2
_ func() = p4.p2
)
}
// Method calls with addressable receivers
func _() {
var v0 T0
v0.v0()
v0.p0()
var p0 *T0
p0.v0()
p0.p0()
// T1 is like T0
var v2 T2
v2.v2()
v2.p2()
var v4 T3
v4.v0()
v4.p0()
v4.v1()
v4.p1()
v4.v2()
v4.p2()
var p4 *T3
p4.v0()
p4.p0()
p4.v1()
p4.p1()
p4.v2()
p4.p2()
}
// Method values with value receivers
func _() {
var (
_ func() = T0{}.v0
_ func() = T0{}.p0 /* ERROR "cannot call pointer method p0 on T0" */
_ func() = (&T0{}).v0
_ func() = (&T0{}).p0
// T1 is like T0
// no values for T2
_ func() = T3{}.v0
_ func() = T3{}.p0 /* ERROR "cannot call pointer method p0 on T3" */
_ func() = T3{}.v1
_ func() = T3{}.p1
_ func() = T3{}.v2
_ func() = T3{}.p2
_ func() = (&T3{}).v0
_ func() = (&T3{}).p0
_ func() = (&T3{}).v1
_ func() = (&T3{}).p1
_ func() = (&T3{}).v2
_ func() = (&T3{}).p2
)
}
// Method calls with value receivers
func _() {
T0{}.v0()
T0{}.p0 /* ERROR "cannot call pointer method p0 on T0" */ ()
(&T0{}).v0()
(&T0{}).p0()
// T1 is like T0
// no values for T2
T3{}.v0()
T3{}.p0 /* ERROR "cannot call pointer method p0 on T3" */ ()
T3{}.v1()
T3{}.p1()
T3{}.v2()
T3{}.p2()
(&T3{}).v0()
(&T3{}).p0()
(&T3{}).v1()
(&T3{}).p1()
(&T3{}).v2()
(&T3{}).p2()
}
// *T has no methods if T is an interface type
func issue5918() {
var (
err error
_ = err.Error()
_ func() string = err.Error
_ func(error) string = error.Error
perr = &err
_ = perr.Error /* ERROR "no field or method" */ ()
_ func() string = perr.Error /* ERROR "no field or method" */
_ func(*error) string = (*error).Error /* ERROR "no field or method" */
)
type T *interface{ m() int }
var (
x T
_ = (*x).m()
_ = (*x).m
_ = x.m /* ERROR "no field or method" */ ()
_ = x.m /* ERROR "no field or method" */
_ = T.m /* ERROR "no field or method" */
)
}

395
src/cmd/compile/internal/types2/testdata/shifts.src vendored Normal file
View file

@ -0,0 +1,395 @@
// 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 shifts
func shifts0() {
// basic constant shifts
const (
s = 10
_ = 0<<0
_ = 1<<s
_ = 1<<- /* ERROR "negative shift count" */ 1
// For the test below we may decide to convert to int
// rather than uint and then report a negative shift
// count instead, which might be a better error. The
// (minor) difference is that this would restrict the
// shift count range by half (from all uint values to
// the positive int values).
// This depends on the exact spec wording which is not
// done yet.
// TODO(gri) revisit and adjust when spec change is done
_ = 1<<- /* ERROR "truncated to uint" */ 1.0
_ = 1<<1075 /* ERROR "invalid shift" */
_ = 2.0<<1
_ = 1<<1.0
_ = 1<<(1+0i)
_ int = 2<<s
_ float32 = 2<<s
_ complex64 = 2<<s
_ int = 2.0<<s
_ float32 = 2.0<<s
_ complex64 = 2.0<<s
_ int = 'a'<<s
_ float32 = 'a'<<s
_ complex64 = 'a'<<s
)
}
func shifts1() {
// basic non-constant shifts
var (
i int
u uint
_ = 1<<0
_ = 1<<i
_ = 1<<u
_ = 1<<"foo" /* ERROR "cannot convert" */
_ = i<<0
_ = i<<- /* ERROR "negative shift count" */ 1
_ = i<<1.0
_ = 1<<(1+0i)
_ = 1 /* ERROR "overflows" */ <<100
_ uint = 1 << 0
_ uint = 1 << u
_ float32 = 1 /* ERROR "must be integer" */ << u
// for issue 14822
_ = 1<<( /* ERROR "invalid shift count" */ 1<<64-1)
_ = 1<<( /* ERROR "invalid shift count" */ 1<<64)
_ = u<<(1<<63) // valid
_ = u<<(1<<64) // valid
)
}
func shifts2() {
// from the spec
var (
s uint = 33
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
m int = 1.0<<s // 1.0 has type int
n = 1.0<<s != i // 1.0 has type int; n == false if ints are 32bits in size
o = 1<<s == 2<<s // 1 and 2 have type int; o == true if ints are 32bits in size
p = 1<<s == 1<<33 // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int
u = 1.0 /* ERROR "must be integer" */ <<s // illegal: 1.0 has type float64, cannot shift
u1 = 1.0 /* ERROR "must be integer" */ <<s != 0 // illegal: 1.0 has type float64, cannot shift
u2 = 1 /* ERROR "must be integer" */ <<s != 1.0 // illegal: 1 has type float64, cannot shift
v float32 = 1 /* ERROR "must be integer" */ <<s // illegal: 1 has type float32, cannot shift
w int64 = 1.0<<33 // 1.0<<33 is a constant shift expression
)
_, _, _, _, _, _, _, _, _, _, _, _ = i, j, k, m, n, o, p, u, u1, u2, v, w
}
func shifts3(a int16, b float32) {
// random tests
var (
s uint = 11
u = 1 /* ERROR "must be integer" */ <<s + 1.0
v complex128 = 1 /* ERROR "must be integer" */ << s + 1.0 /* ERROR "must be integer" */ << s + 1
)
x := 1.0 /* ERROR "must be integer" */ <<s + 1
shifts3(1.0 << s, 1 /* ERROR "must be integer" */ >> s)
_, _, _ = u, v, x
}
func shifts4() {
// shifts in comparisons w/ untyped operands
var s uint
_ = 1<<s == 1
_ = 1 /* ERROR "integer" */ <<s == 1.
_ = 1. /* ERROR "integer" */ <<s == 1
_ = 1. /* ERROR "integer" */ <<s == 1.
_ = 1<<s + 1 == 1
_ = 1 /* ERROR "integer" */ <<s + 1 == 1.
_ = 1 /* ERROR "integer" */ <<s + 1. == 1
_ = 1 /* ERROR "integer" */ <<s + 1. == 1.
_ = 1. /* ERROR "integer" */ <<s + 1 == 1
_ = 1. /* ERROR "integer" */ <<s + 1 == 1.
_ = 1. /* ERROR "integer" */ <<s + 1. == 1
_ = 1. /* ERROR "integer" */ <<s + 1. == 1.
_ = 1<<s == 1<<s
_ = 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s
_ = 1<<s + 1<<s == 1
_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1.
_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1
_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1.
_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1
_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1.
_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1
_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1.
_ = 1<<s + 1<<s == 1<<s + 1<<s
_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1 /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1 /* ERROR "integer" */ <<s
_ = 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s == 1. /* ERROR "integer" */ <<s + 1. /* ERROR "integer" */ <<s
}
func shifts5() {
// shifts in comparisons w/ typed operands
var s uint
var x int
_ = 1<<s == x
_ = 1.<<s == x
_ = 1.1 /* ERROR "int" */ <<s == x
_ = 1<<s + x == 1
_ = 1<<s + x == 1.
_ = 1<<s + x == 1.1 /* ERROR "int" */
_ = 1.<<s + x == 1
_ = 1.<<s + x == 1.
_ = 1.<<s + x == 1.1 /* ERROR "int" */
_ = 1.1 /* ERROR "int" */ <<s + x == 1
_ = 1.1 /* ERROR "int" */ <<s + x == 1.
_ = 1.1 /* ERROR "int" */ <<s + x == 1.1
_ = 1<<s == x<<s
_ = 1.<<s == x<<s
_ = 1.1 /* ERROR "int" */ <<s == x<<s
}
func shifts6() {
// shifts as operands in non-arithmetic operations and as arguments
var a [10]int
var s uint
_ = a[1<<s]
_ = a[1.0]
_ = a[1.0<<s]
_ = make([]int, 1.0)
_ = make([]int, 1.0<<s)
_ = make([]int, 1.1 /* ERROR "must be integer" */ <<s)
_ = float32(1)
_ = float32(1 /* ERROR "must be integer" */ <<s)
_ = float32(1.0)
_ = float32(1.0 /* ERROR "must be integer" */ <<s)
_ = float32(1.1 /* ERROR "must be integer" */ <<s)
_ = int32(0x80000000 /* ERROR "overflows int32" */ << s)
// TODO(rfindley) Eliminate the redundant error here.
_ = int32(( /* ERROR "truncated to int32" */ 0x80000000 /* ERROR "truncated to int32" */ + 0i) << s)
_ = int(1+0i<<0)
_ = int((1+0i)<<s)
_ = int(1.0<<s)
_ = int(complex(1, 0)<<s)
_ = int(float32/* ERROR "must be integer" */(1.0) <<s)
_ = int(1.1 /* ERROR must be integer */ <<s)
_ = int(( /* ERROR "must be integer" */ 1+1i) <<s)
_ = complex(1 /* ERROR "must be integer" */ <<s, 0)
var b []int
_ = append(b, 1<<s)
_ = append(b, 1.0<<s)
_ = append(b, (1+0i)<<s)
_ = append(b, 1.1 /* ERROR "must be integer" */ <<s)
_ = append(b, (1 + 0i) <<s)
_ = append(b, ( /* ERROR "must be integer" */ 1 + 1i) <<s)
_ = complex(1.0 /* ERROR "must be integer" */ <<s, 0)
_ = complex(1.1 /* ERROR "must be integer" */ <<s, 0)
_ = complex(0, 1.0 /* ERROR "must be integer" */ <<s)
_ = complex(0, 1.1 /* ERROR "must be integer" */ <<s)
// TODO(gri) The delete below is not type-checked correctly yet.
// var m1 map[int]string
// delete(m1, 1<<s)
}
func shifts7() {
// shifts of shifts
var s uint
var x int
_ = x
_ = 1<<(1<<s)
_ = 1<<(1.<<s)
_ = 1. /* ERROR "integer" */ <<(1<<s)
_ = 1. /* ERROR "integer" */ <<(1.<<s)
x = 1<<(1<<s)
x = 1<<(1.<<s)
x = 1.<<(1<<s)
x = 1.<<(1.<<s)
_ = (1<<s)<<(1<<s)
_ = (1<<s)<<(1.<<s)
_ = ( /* ERROR "integer" */ 1.<<s)<<(1<<s)
_ = ( /* ERROR "integer" */ 1.<<s)<<(1.<<s)
x = (1<<s)<<(1<<s)
x = (1<<s)<<(1.<<s)
x = ( /* ERROR "integer" */ 1.<<s)<<(1<<s)
x = ( /* ERROR "integer" */ 1.<<s)<<(1.<<s)
}
func shifts8() {
// shift examples from shift discussion: better error messages
var s uint
_ = 1.0 /* ERROR "shifted operand 1.0 \(type float64\) must be integer" */ <<s == 1
_ = 1.0 /* ERROR "shifted operand 1.0 \(type float64\) must be integer" */ <<s == 1.0
_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s == 1.0
_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s + 1.0 == 1
_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s + 1.1 == 1
_ = 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s + 1 == 1.0
// additional cases
_ = complex(1.0 /* ERROR "shifted operand 1.0 \(type float64\) must be integer" */ <<s, 1)
_ = complex(1.0, 1 /* ERROR "shifted operand 1 \(type float64\) must be integer" */ <<s)
_ = int(1.<<s)
_ = int(1.1 /* ERROR "shifted operand .* must be integer" */ <<s)
_ = float32(1 /* ERROR "shifted operand .* must be integer" */ <<s)
_ = float32(1. /* ERROR "shifted operand .* must be integer" */ <<s)
_ = float32(1.1 /* ERROR "shifted operand .* must be integer" */ <<s)
// TODO(gri) the error messages for these two are incorrect - disabled for now
// _ = complex64(1<<s)
// _ = complex64(1.<<s)
_ = complex64(1.1 /* ERROR "shifted operand .* must be integer" */ <<s)
}
func shifts9() {
// various originally failing snippets of code from the std library
// from src/compress/lzw/reader.go:90
{
var d struct {
bits uint32
width uint
}
_ = uint16(d.bits & (1<<d.width - 1))
}
// from src/debug/dwarf/buf.go:116
{
var ux uint64
var bits uint
x := int64(ux)
if x&(1<<(bits-1)) != 0 {}
}
// from src/encoding/asn1/asn1.go:160
{
var bytes []byte
if bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {}
}
// from src/math/big/rat.go:140
{
var exp int
var mantissa uint64
shift := uint64(-1022 - (exp - 1)) // [1..53)
_ = mantissa & (1<<shift - 1)
}
// from src/net/interface.go:51
{
type Flags uint
var f Flags
var i int
if f&(1<<uint(i)) != 0 {}
}
// from src/runtime/softfloat64.go:234
{
var gm uint64
var shift uint
_ = gm & (1<<shift - 1)
}
// from src/strconv/atof.go:326
{
var mant uint64
var mantbits uint
if mant == 2<<mantbits {}
}
// from src/route_bsd.go:82
{
var Addrs int32
const rtaRtMask = 1
var i uint
if Addrs&rtaRtMask&(1<<i) == 0 {}
}
// from src/text/scanner/scanner.go:540
{
var s struct { Whitespace uint64 }
var ch rune
for s.Whitespace&(1<<uint(ch)) != 0 {}
}
}
func issue5895() {
var x = 'a' << 1 // type of x must be rune
var _ rune = x
}
func issue11325() {
var _ = 0 >> 1.1 /* ERROR "truncated to uint" */ // example from issue 11325
_ = 0 >> 1.1 /* ERROR "truncated to uint" */
_ = 0 << 1.1 /* ERROR "truncated to uint" */
_ = 0 >> 1.
_ = 1 >> 1.1 /* ERROR "truncated to uint" */
_ = 1 >> 1.
_ = 1. >> 1
_ = 1. >> 1.
_ = 1.1 /* ERROR "must be integer" */ >> 1
}
func issue11594() {
var _ = complex64 /* ERROR "must be integer" */ (1) << 2 // example from issue 11594
_ = float32 /* ERROR "must be integer" */ (0) << 1
_ = float64 /* ERROR "must be integer" */ (0) >> 2
_ = complex64 /* ERROR "must be integer" */ (0) << 3
_ = complex64 /* ERROR "must be integer" */ (0) >> 4
}
func issue21727() {
var s uint
var a = make([]int, 1<<s + 1.2 /* ERROR "truncated to int" */ )
var _ = a[1<<s - 2.3 /* ERROR "truncated to int" */ ]
var _ int = 1<<s + 3.4 /* ERROR "truncated to int" */
var _ = string(1 << s)
var _ = string(1.0 /* ERROR "cannot convert" */ << s)
}
func issue22969() {
var s uint
var a []byte
_ = a[0xffffffffffffffff /* ERROR "overflows int" */ <<s] // example from issue 22969
_ = make([]int, 0xffffffffffffffff /* ERROR "overflows int" */ << s)
_ = make([]int, 0, 0xffffffffffffffff /* ERROR "overflows int" */ << s)
var _ byte = 0x100 /* ERROR "overflows byte" */ << s
var _ int8 = 0xff /* ERROR "overflows int8" */ << s
var _ int16 = 0xffff /* ERROR "overflows int16" */ << s
var _ int32 = 0x80000000 /* ERROR "overflows int32" */ << s
}

980
src/cmd/compile/internal/types2/testdata/stmt0.src vendored Normal file
View file

@ -0,0 +1,980 @@
// 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.
// statements
package stmt0
func assignments0() (int, int) {
var a, b, c int
var ch chan int
f0 := func() {}
f1 := func() int { return 1 }
f2 := func() (int, int) { return 1, 2 }
f3 := func() (int, int, int) { return 1, 2, 3 }
a, b, c = 1, 2, 3
a, b, c = 1 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ , 2
a, b, c = 1 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ , 2, 3, 4
_, _, _ = a, b, c
a = f0 /* ERROR "used as value" */ ()
a = f1()
a = f2 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ()
a, b = f2()
a, b, c = f2 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ()
a, b, c = f3()
a, b = f3 /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ()
a, b, c = <- /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ch
return /* ERROR "wrong number of return values" */
return /* ERROR "wrong number of return values" */ 1
return 1, 2
return /* ERROR "wrong number of return values" */ 1, 2, 3
}
func assignments1() {
b, i, f, c, s := false, 1, 1.0, 1i, "foo"
b = i /* ERROR "cannot use .* in assignment" */
i = f /* ERROR "cannot use .* in assignment" */
f = c /* ERROR "cannot use .* in assignment" */
c = s /* ERROR "cannot use .* in assignment" */
s = b /* ERROR "cannot use .* in assignment" */
v0, v1, v2 := 1 /* ERROR "cannot initialize" */ , 2, 3, 4
_, _, _ = v0, v1, v2
b = true
i += 1
i += "foo" /* ERROR "cannot convert.*int" */
f -= 1
f /= 0
f = float32(0)/0 /* ERROR "division by zero" */
f -= "foo" /* ERROR "cannot convert.*float64" */
c *= 1
c /= 0
s += "bar"
s += 1 /* ERROR "cannot convert.*string" */
var u64 uint64
u64 += 1<<u64
undeclared /* ERROR "undeclared" */ = 991
// test cases for issue 5800
var (
_ int = nil /* ERROR "untyped nil value" */
_ [10]int = nil /* ERROR "untyped nil value" */
_ []byte = nil
_ struct{} = nil /* ERROR "untyped nil value" */
_ func() = nil
_ map[int]string = nil
_ chan int = nil
)
// test cases for issue 5500
_ = func() (int, bool) {
var m map[int]int
return /* ERROR "wrong number of return values" */ m[0]
}
g := func(int, bool){}
var m map[int]int
g(m[0]) /* ERROR "too few arguments" */
// assignments to _
_ = nil /* ERROR "use of untyped nil" */
_ = 1 /* ERROR overflow */ <<1000
(_) = 0
}
func assignments2() {
type mybool bool
var m map[string][]bool
var s []bool
var b bool
var d mybool
_ = s
_ = b
_ = d
// assignments to map index expressions are ok
s, b = m["foo"]
_, d = m["bar"]
m["foo"] = nil
m["foo"] = nil /* ERROR cannot assign [1-9]+ values to [1-9]+ variables */ , false
_ = append(m["foo"])
_ = append(m["foo"], true)
var c chan int
_, b = <-c
_, d = <-c
<- /* ERROR cannot assign */ c = 0
<-c = 0 /* ERROR cannot assign [1-9]+ values to [1-9]+ variables */ , false
var x interface{}
_, b = x.(int)
x /* ERROR cannot assign */ .(int) = 0
x.(int) = 0 /* ERROR cannot assign [1-9]+ values to [1-9]+ variables */ , false
assignments2 /* ERROR used as value */ () = nil
int /* ERROR not an expression */ = 0
}
func issue6487() {
type S struct{x int}
_ = &S /* ERROR "cannot take address" */ {}.x
_ = &( /* ERROR "cannot take address" */ S{}.x)
_ = (&S{}).x
S /* ERROR "cannot assign" */ {}.x = 0
(&S{}).x = 0
type M map[string]S
var m M
m /* ERROR "cannot assign to struct field" */ ["foo"].x = 0
_ = &( /* ERROR "cannot take address" */ m["foo"].x)
_ = &m /* ERROR "cannot take address" */ ["foo"].x
}
func issue6766a() {
a, a /* ERROR redeclared */ := 1, 2
_ = a
a, b, b /* ERROR redeclared */ := 1, 2, 3
_ = b
c, c /* ERROR redeclared */, b := 1, 2, 3
_ = c
a, b := /* ERROR no new variables */ 1, 2
}
func shortVarDecls1() {
const c = 0
type d int
a, b, c /* ERROR "cannot assign" */ , d /* ERROR "cannot assign" */ := 1, "zwei", 3.0, 4
var _ int = a // a is of type int
var _ string = b // b is of type string
}
func incdecs() {
const c = 3.14
c /* ERROR "cannot assign" */ ++
s := "foo"
s /* ERROR "invalid operation" */ --
3.14 /* ERROR "cannot assign" */ ++
var (
x int
y float32
z complex128
)
x++
y--
z++
}
func sends() {
var ch chan int
var rch <-chan int
var x int
x <- /* ERROR "cannot send" */ x
rch <- /* ERROR "cannot send" */ x
ch <- "foo" /* ERROR "cannot convert" */
ch <- x
}
func selects() {
select {}
var (
ch chan int
sc chan <- bool
)
select {
case <-ch:
case (<-ch):
case t := <-ch:
_ = t
case t := (<-ch):
_ = t
case t, ok := <-ch:
_, _ = t, ok
case t, ok := (<-ch):
_, _ = t, ok
case <-sc /* ERROR "cannot receive from send-only channel" */ :
}
select {
default:
default /* ERROR "multiple defaults" */ :
}
select {
case a, b := <-ch:
_, b = a, b
case x /* ERROR send or receive */ :
case a /* ERROR send or receive */ := ch:
}
// test for issue 9570: ch2 in second case falsely resolved to
// ch2 declared in body of first case
ch1 := make(chan int)
ch2 := make(chan int)
select {
case <-ch1:
var ch2 /* ERROR ch2 declared but not used */ chan bool
case i := <-ch2:
print(i + 1)
}
}
func gos() {
go 1 /* ERROR HERE "function must be invoked" */
go int /* ERROR "go requires function call, not conversion" */ (0)
go gos()
var c chan int
go close(c)
go len /* ERROR "go discards result" */ (c)
}
func defers() {
defer 1 /* ERROR HERE "function must be invoked" */
defer int /* ERROR "defer requires function call, not conversion" */ (0)
defer defers()
var c chan int
defer close(c)
defer len /* ERROR "defer discards result" */ (c)
}
func breaks() {
var x, y int
break /* ERROR "break" */
{
break /* ERROR "break" */
}
if x < y {
break /* ERROR "break" */
}
switch x {
case 0:
break
case 1:
if x == y {
break
}
default:
break
break
}
var z interface{}
switch z.(type) {
case int:
break
}
for {
break
}
var a []int
for _ = range a {
break
}
for {
if x == y {
break
}
}
var ch chan int
select {
case <-ch:
break
}
select {
case <-ch:
if x == y {
break
}
default:
break
}
}
func continues() {
var x, y int
continue /* ERROR "continue" */
{
continue /* ERROR "continue" */
}
if x < y {
continue /* ERROR "continue" */
}
switch x {
case 0:
continue /* ERROR "continue" */
}
var z interface{}
switch z.(type) {
case int:
continue /* ERROR "continue" */
}
var ch chan int
select {
case <-ch:
continue /* ERROR "continue" */
}
for i := 0; i < 10; i++ {
continue
if x < y {
continue
break
}
switch x {
case y:
continue
default:
break
}
select {
case <-ch:
continue
}
}
var a []int
for _ = range a {
continue
if x < y {
continue
break
}
switch x {
case y:
continue
default:
break
}
select {
case <-ch:
continue
}
}
}
func returns0() {
return
return 0 /* ERROR no result values expected */
}
func returns1(x float64) (int, *float64) {
return 0, &x
return /* ERROR wrong number of return values */
return "foo" /* ERROR "cannot convert" */, x /* ERROR "cannot use .* in return statement" */
return /* ERROR wrong number of return values */ 0, &x, 1
}
func returns2() (a, b int) {
return
return 1, "foo" /* ERROR cannot convert */
return /* ERROR wrong number of return values */ 1, 2, 3
{
type a int
return 1, 2
return /* ERROR a not in scope at return */
}
}
func returns3() (_ int) {
return
{
var _ int // blank (_) identifiers never shadow since they are in no scope
return
}
}
func switches0() {
var x int
switch x {
}
switch x {
default:
default /* ERROR "multiple defaults" */ :
}
switch {
case 1 /* ERROR "cannot convert" */ :
}
true := "false"
_ = true
// A tagless switch is equivalent to the bool
// constant true, not the identifier 'true'.
switch {
case "false" /* ERROR "cannot convert" */:
}
switch int32(x) {
case 1, 2:
case x /* ERROR "cannot compare" */ :
}
switch x {
case 1 /* ERROR "overflows" */ << 100:
}
switch x {
case 1:
case 1 /* ERROR "duplicate case" */ :
case ( /* ERROR "duplicate case" */ 1):
case 2, 3, 4:
case 5, 1 /* ERROR "duplicate case" */ :
}
switch uint64(x) {
case 1<<64 - 1:
case 1 /* ERROR duplicate case */ <<64 - 1:
case 2, 3, 4:
case 5, 1 /* ERROR duplicate case */ <<64 - 1:
}
var y32 float32
switch y32 {
case 1.1:
case 11/10: // integer division!
case 11. /* ERROR duplicate case */ /10:
case 2, 3.0, 4.1:
case 5.2, 1.10 /* ERROR duplicate case */ :
}
var y64 float64
switch y64 {
case 1.1:
case 11/10: // integer division!
case 11. /* ERROR duplicate case */ /10:
case 2, 3.0, 4.1:
case 5.2, 1.10 /* ERROR duplicate case */ :
}
var s string
switch s {
case "foo":
case "foo" /* ERROR duplicate case */ :
case "f" /* ERROR duplicate case */ + "oo":
case "abc", "def", "ghi":
case "jkl", "foo" /* ERROR duplicate case */ :
}
type T int
type F float64
type S string
type B bool
var i interface{}
switch i {
case nil:
case nil: // no duplicate detection
case (*int)(nil):
case (*int)(nil): // do duplicate detection
case 1:
case byte(1):
case int /* ERROR duplicate case */ (1):
case T(1):
case 1.0:
case F(1.0):
case F /* ERROR duplicate case */ (1.0):
case "hello":
case S("hello"):
case S /* ERROR duplicate case */ ("hello"):
case 1==1, B(false):
case false, B(2==2):
}
// switch on array
var a [3]int
switch a {
case [3]int{1, 2, 3}:
case [3]int{1, 2, 3}: // no duplicate detection
case [ /* ERROR "mismatched types */ 4]int{4, 5, 6}:
}
// switch on channel
var c1, c2 chan int
switch c1 {
case nil:
case c1:
case c2:
case c1, c2: // no duplicate detection
}
}
func switches1() {
fallthrough /* ERROR "fallthrough statement out of place" */
var x int
switch x {
case 0:
fallthrough /* ERROR "fallthrough statement out of place" */
break
case 1:
fallthrough
case 2:
fallthrough; ; ; // trailing empty statements are ok
case 3:
default:
fallthrough; ;
case 4:
fallthrough /* ERROR "cannot fallthrough final case in switch" */
}
var y interface{}
switch y.(type) {
case int:
fallthrough /* ERROR "fallthrough statement out of place" */ ; ; ;
default:
}
switch x {
case 0:
if x == 0 {
fallthrough /* ERROR "fallthrough statement out of place" */
}
}
switch x {
case 0:
goto L1
L1: fallthrough; ;
case 1:
goto L2
goto L3
goto L4
L2: L3: L4: fallthrough
default:
}
switch x {
case 0:
goto L5
L5: fallthrough
default:
goto L6
goto L7
goto L8
L6: L7: L8: fallthrough /* ERROR "cannot fallthrough final case in switch" */
}
switch x {
case 0:
fallthrough; ;
case 1:
{
fallthrough /* ERROR "fallthrough statement out of place" */
}
case 2:
fallthrough
case 3:
fallthrough /* ERROR "fallthrough statement out of place" */
{ /* empty block is not an empty statement */ }; ;
default:
fallthrough /* ERROR "cannot fallthrough final case in switch" */
}
switch x {
case 0:
{
fallthrough /* ERROR "fallthrough statement out of place" */
}
}
}
func switches2() {
// untyped nil is not permitted as switch expression
switch nil /* ERROR "use of untyped nil" */ {
case 1, 2, "foo": // don't report additional errors here
}
// untyped constants are converted to default types
switch 1<<63-1 {
}
switch 1 /* ERROR "overflows int" */ << 63 {
}
var x int
switch 1.0 {
case 1.0, 2.0, x /* ERROR "mismatched types int and float64" */ :
}
switch x {
case 1.0:
}
// untyped bools become of type bool
type B bool
var b B = true
switch x == x {
case b /* ERROR "mismatched types B and bool" */ :
}
switch {
case b /* ERROR "mismatched types B and bool" */ :
}
}
func issue11667() {
switch 9223372036854775808 /* ERROR "overflows int" */ {
}
switch 9223372036854775808 /* ERROR "overflows int" */ {
case 9223372036854775808:
}
var x int
switch x {
case 9223372036854775808 /* ERROR "overflows int" */ :
}
var y float64
switch y {
case 9223372036854775808:
}
}
func issue11687() {
f := func() (_, _ int) { return }
switch f /* ERROR "2-valued f" */ () {
}
var x int
switch f /* ERROR "2-valued f" */ () {
case x:
}
switch x {
case f /* ERROR "2-valued f" */ ():
}
}
type I interface {
m()
}
type I2 interface {
m(int)
}
type T struct{}
type T1 struct{}
type T2 struct{}
func (T) m() {}
func (T2) m(int) {}
func typeswitches() {
var i int
var x interface{}
switch x.(type) {}
switch (x /* ERROR "outside type switch" */ .(type)) {}
switch x.(type) {
default:
default /* ERROR "multiple defaults" */ :
}
switch x /* ERROR "declared but not used" */ := x.(type) {}
switch _ /* ERROR "no new variable on left side of :=" */ := x.(type) {}
switch x := x.(type) {
case int:
var y int = x
_ = y
}
switch x := i /* ERROR "not an interface" */ .(type) {}
switch t := x.(type) {
case nil:
var v bool = t /* ERROR "cannot use .* in variable declaration" */
_ = v
case int:
var v int = t
_ = v
case float32, complex64:
var v float32 = t /* ERROR "cannot use .* in variable declaration" */
_ = v
default:
var v float32 = t /* ERROR "cannot use .* in variable declaration" */
_ = v
}
var t I
switch t.(type) {
case T:
case T1 /* ERROR "missing method m" */ :
case T2 /* ERROR "wrong type for method m" */ :
case I2 /* STRICT "wrong type for method m" */ : // only an error in strict mode (issue 8561)
}
}
// Test that each case clause uses the correct type of the variable
// declared by the type switch (issue 5504).
func typeswitch0() {
switch y := interface{}(nil).(type) {
case int:
func() int { return y + 0 }()
case float32:
func() float32 { return y }()
}
}
// Test correct scope setup.
// (no redeclaration errors expected in the type switch)
func typeswitch1() {
var t I
switch t := t; t := t.(type) {
case nil:
var _ I = t
case T:
var _ T = t
default:
var _ I = t
}
}
// Test correct typeswitch against interface types.
type A interface { a() }
type B interface { b() }
type C interface { a(int) }
func typeswitch2() {
switch A(nil).(type) {
case A:
case B:
case C /* STRICT "cannot have dynamic type" */: // only an error in strict mode (issue 8561)
}
}
func typeswitch3(x interface{}) {
switch x.(type) {
case int:
case float64:
case int /* ERROR duplicate case */ :
}
switch x.(type) {
case nil:
case int:
case nil /* ERROR duplicate case */ , nil /* ERROR duplicate case */ :
}
type F func(int)
switch x.(type) {
case nil:
case int, func(int):
case float32, func /* ERROR duplicate case */ (x int):
case F:
}
}
func fors1() {
for {}
var i string
_ = i
for i := 0; i < 10; i++ {}
for i := 0; i < 10; j /* ERROR cannot declare */ := 0 {}
}
func rangeloops1() {
var (
x int
a [10]float32
b []string
p *[10]complex128
pp **[10]complex128
s string
m map[int]bool
c chan int
sc chan<- int
rc <-chan int
)
for range x /* ERROR "cannot range over" */ {}
for _ = range x /* ERROR "cannot range over" */ {}
for i := range x /* ERROR "cannot range over" */ {}
for range a {}
for i := range a {
var ii int
ii = i
_ = ii
}
for i, x := range a {
var ii int
ii = i
_ = ii
var xx float64
xx = x /* ERROR "cannot use .* in assignment" */
_ = xx
}
var ii int
var xx float32
for ii, xx = range a {}
_, _ = ii, xx
for range b {}
for i := range b {
var ii int
ii = i
_ = ii
}
for i, x := range b {
var ii int
ii = i
_ = ii
var xx string
xx = x
_ = xx
}
for range s {}
for i := range s {
var ii int
ii = i
_ = ii
}
for i, x := range s {
var ii int
ii = i
_ = ii
var xx rune
xx = x
_ = xx
}
for range p {}
for _, x := range p {
var xx complex128
xx = x
_ = xx
}
for range pp /* ERROR "cannot range over" */ {}
for _, x := range pp /* ERROR "cannot range over" */ {}
for range m {}
for k := range m {
var kk int32
kk = k /* ERROR "cannot use .* in assignment" */
_ = kk
}
for k, v := range m {
var kk int
kk = k
_ = kk
if v {}
}
for range c {}
for _, _ /* ERROR "only one iteration variable" */ = range c {}
for e := range c {
var ee int
ee = e
_ = ee
}
for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
for _ = range rc {}
// constant strings
const cs = "foo"
for range cs {}
for range "" {}
for i, x := range cs { _, _ = i, x }
for i, x := range "" {
var ii int
ii = i
_ = ii
var xx rune
xx = x
_ = xx
}
}
func rangeloops2() {
type I int
type R rune
var a [10]int
var i I
_ = i
for i /* ERROR cannot use .* in assignment */ = range a {}
for i /* ERROR cannot use .* in assignment */ = range &a {}
for i /* ERROR cannot use .* in assignment */ = range a[:] {}
var s string
var r R
_ = r
for i /* ERROR cannot use .* in assignment */ = range s {}
for i /* ERROR cannot use .* in assignment */ = range "foo" {}
for _, r /* ERROR cannot use .* in assignment */ = range s {}
for _, r /* ERROR cannot use .* in assignment */ = range "foo" {}
}
func issue6766b() {
for _ := /* ERROR no new variables */ range "" {}
for a, a /* ERROR redeclared */ := range "" { _ = a }
var a int
_ = a
for a, a /* ERROR redeclared */ := range []int{1, 2, 3} { _ = a }
}
// Test that despite errors in the range clause,
// the loop body is still type-checked (and thus
// errors reported).
func issue10148() {
for y /* ERROR declared but not used */ := range "" {
_ = "" /* ERROR cannot convert */ + 1
}
for range 1 /* ERROR cannot range over 1 */ {
_ = "" /* ERROR cannot convert */ + 1
}
for y := range 1 /* ERROR cannot range over 1 */ {
_ = "" /* ERROR cannot convert */ + 1
}
}
func labels0() {
goto L0
goto L1
L0:
L1:
L1 /* ERROR "already declared" */ :
if true {
goto L2
L2:
L0 /* ERROR "already declared" */ :
}
_ = func() {
goto L0
goto L1
goto L2
L0:
L1:
L2:
}
}
func expression_statements(ch chan int) {
expression_statements(ch)
<-ch
println()
0 /* ERROR "not used" */
1 /* ERROR "not used" */ +2
cap /* ERROR "not used" */ (ch)
println /* ERROR "must be called" */
}

259
src/cmd/compile/internal/types2/testdata/stmt1.src vendored Normal file
View file

@ -0,0 +1,259 @@
// 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.
// terminating statements
package stmt1
func _() {}
func _() int {} /* ERROR "missing return" */
func _() int { panic(0) }
func _() int { (panic(0)) }
// block statements
func _(x, y int) (z int) {
{
return
}
}
func _(x, y int) (z int) {
{
return; ; ; // trailing empty statements are ok
}
; ; ;
}
func _(x, y int) (z int) {
{
}
} /* ERROR "missing return" */
func _(x, y int) (z int) {
{
; ; ;
}
; ; ;
} /* ERROR "missing return" */
// if statements
func _(x, y int) (z int) {
if x < y { return }
return 1
}
func _(x, y int) (z int) {
if x < y { return; ; ; ; }
return 1
}
func _(x, y int) (z int) {
if x < y { return }
return 1; ;
}
func _(x, y int) (z int) {
if x < y { return }
} /* ERROR "missing return" */
func _(x, y int) (z int) {
if x < y {
} else { return 1
}
} /* ERROR "missing return" */
func _(x, y int) (z int) {
if x < y { return
} else { return
}
}
// for statements
func _(x, y int) (z int) {
for x < y {
return
}
} /* ERROR "missing return" */
func _(x, y int) (z int) {
for {
return
}
}
func _(x, y int) (z int) {
for {
return; ; ; ;
}
}
func _(x, y int) (z int) {
for {
return
break
}
; ; ;
} /* ERROR "missing return" */
func _(x, y int) (z int) {
for {
for { break }
return
}
}
func _(x, y int) (z int) {
for {
for { break }
return ; ;
}
;
}
func _(x, y int) (z int) {
L: for {
for { break L }
return
}
} /* ERROR "missing return" */
// switch statements
func _(x, y int) (z int) {
switch x {
case 0: return
default: return
}
}
func _(x, y int) (z int) {
switch x {
case 0: return;
default: return; ; ;
}
}
func _(x, y int) (z int) {
switch x {
case 0: return
}
} /* ERROR "missing return" */
func _(x, y int) (z int) {
switch x {
case 0: return
case 1: break
}
} /* ERROR "missing return" */
func _(x, y int) (z int) {
switch x {
case 0: return
default:
switch y {
case 0: break
}
panic(0)
}
}
func _(x, y int) (z int) {
switch x {
case 0: return
default:
switch y {
case 0: break
}
panic(0); ; ;
}
;
}
func _(x, y int) (z int) {
L: switch x {
case 0: return
default:
switch y {
case 0: break L
}
panic(0)
}
} /* ERROR "missing return" */
// select statements
func _(ch chan int) (z int) {
select {}
} // nice!
func _(ch chan int) (z int) {
select {}
; ;
}
func _(ch chan int) (z int) {
select {
default: break
}
} /* ERROR "missing return" */
func _(ch chan int) (z int) {
select {
case <-ch: return
default: break
}
} /* ERROR "missing return" */
func _(ch chan int) (z int) {
select {
case <-ch: return
default:
for i := 0; i < 10; i++ {
break
}
return
}
}
func _(ch chan int) (z int) {
select {
case <-ch: return; ; ;
default:
for i := 0; i < 10; i++ {
break
}
return; ; ;
}
; ; ;
}
func _(ch chan int) (z int) {
L: select {
case <-ch: return
default:
for i := 0; i < 10; i++ {
break L
}
return
}
; ; ;
} /* ERROR "missing return" */
func parenPanic() int {
((((((panic)))(0))))
}
func issue23218a() int {
{
panic := func(interface{}){}
panic(0)
}
} /* ERROR "missing return" */
func issue23218b() int {
{
panic := func(interface{}){}
((((panic))))(0)
}
} /* ERROR "missing return" */

206
src/cmd/compile/internal/types2/testdata/vardecl.src vendored Normal file
View file

@ -0,0 +1,206 @@
// 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 vardecl
// Prerequisites.
import "math"
func f() {}
func g() (x, y int) { return }
var m map[string]int
// Var decls must have a type or an initializer.
var _ int
var _, _ int
// The first error message is produced by the parser.
// In a real-world scenario, the type-checker would not be run
// in this case and the 2nd error message would not appear.
var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */
var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _
var _ /* ERROR "missing variable type" */ /* ERROR "missing type or init expr" */, _, _
// The initializer must be an expression.
var _ = int /* ERROR "not an expression" */
var _ = f /* ERROR "used as value" */ ()
// Identifier and expression arity must match.
var _, _ = 1, 2
var _ = 1, 2 /* ERROR "extra init expr 2" */
var _, _ = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
var _, _, _ /* ERROR "missing init expr for _" */ = 1, 2
var _ = g /* ERROR "2-valued g" */ ()
var _, _ = g()
var _, _, _ = g /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ()
var _ = m["foo"]
var _, _ = m["foo"]
var _, _, _ = m /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ["foo"]
var _, _ int = 1, 2
var _ int = 1, 2 /* ERROR "extra init expr 2" */
var _, _ int = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
var _, _, _ /* ERROR "missing init expr for _" */ int = 1, 2
var (
_, _ = 1, 2
_ = 1, 2 /* ERROR "extra init expr 2" */
_, _ = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
_, _, _ /* ERROR "missing init expr for _" */ = 1, 2
_ = g /* ERROR "2-valued g" */ ()
_, _ = g()
_, _, _ = g /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ()
_ = m["foo"]
_, _ = m["foo"]
_, _, _ = m /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */ ["foo"]
_, _ int = 1, 2
_ int = 1, 2 /* ERROR "extra init expr 2" */
_, _ int = 1 /* ERROR "cannot initialize [0-9]+ variables with [0-9]+ values" */
_, _, _ /* ERROR "missing init expr for _" */ int = 1, 2
)
// Variables declared in function bodies must be 'used'.
type T struct{}
func (r T) _(a, b, c int) (u, v, w int) {
var x1 /* ERROR "declared but not used" */ int
var x2 /* ERROR "declared but not used" */ int
x1 = 1
(x2) = 2
y1 /* ERROR "declared but not used" */ := 1
y2 /* ERROR "declared but not used" */ := 2
y1 = 1
(y1) = 2
{
var x1 /* ERROR "declared but not used" */ int
var x2 /* ERROR "declared but not used" */ int
x1 = 1
(x2) = 2
y1 /* ERROR "declared but not used" */ := 1
y2 /* ERROR "declared but not used" */ := 2
y1 = 1
(y1) = 2
}
if x /* ERROR "declared but not used" */ := 0; a < b {}
switch x /* ERROR "declared but not used" */, y := 0, 1; a {
case 0:
_ = y
case 1:
x /* ERROR "declared but not used" */ := 0
}
var t interface{}
switch t /* ERROR "declared but not used" */ := t.(type) {}
switch t /* ERROR "declared but not used" */ := t.(type) {
case int:
}
switch t /* ERROR "declared but not used" */ := t.(type) {
case int:
case float32, complex64:
t = nil
}
switch t := t.(type) {
case int:
case float32, complex64:
_ = t
}
switch t := t.(type) {
case int:
case float32:
case string:
_ = func() string {
return t
}
}
switch t := t; t /* ERROR "declared but not used" */ := t.(type) {}
var z1 /* ERROR "declared but not used" */ int
var z2 int
_ = func(a, b, c int) (u, v, w int) {
z1 = a
(z1) = b
a = z2
return
}
var s []int
var i /* ERROR "declared but not used" */ , j int
for i, j = range s {
_ = j
}
for i, j /* ERROR "declared but not used" */ := range s {
_ = func() int {
return i
}
}
return
}
// Unused variables in function literals must lead to only one error (issue #22524).
func _() {
_ = func() {
var x /* ERROR declared but not used */ int
}
}
// Invalid (unused) expressions must not lead to spurious "declared but not used errors"
func _() {
var a, b, c int
var x, y int
x, y = a /* ERROR cannot assign [0-9]+ values to [0-9]+ variables */ , b, c
_ = x
_ = y
}
func _() {
var x int
return x /* ERROR no result values expected */
return math /* ERROR no result values expected */ .Sin(0)
}
func _() int {
var x, y int
return /* ERROR wrong number of return values */ x, y
}
// Short variable declarations must declare at least one new non-blank variable.
func _() {
_ := /* ERROR no new variables */ 0
_, a := 0, 1
_, a := /* ERROR no new variables */ 0, 1
_, a, b := 0, 1, 2
_, _, _ := /* ERROR no new variables */ 0, 1, 2
_ = a
_ = b
}
// Test case for variables depending on function literals (see also #22992).
var A /* ERROR initialization cycle */ = func() int { return A }()
func _() {
// The function literal below must not see a.
var a = func() int { return a /* ERROR "undeclared name" */ }()
var _ = func() int { return a }()
// The function literal below must not see x, y, or z.
var x, y, z = 0, 1, func() int { return x /* ERROR "undeclared name" */ + y /* ERROR "undeclared name" */ + z /* ERROR "undeclared name" */ }()
_, _, _ = x, y, z
}
// TODO(gri) consolidate other var decl checks in this file