mirror of
https://gcc.gnu.org/git/gcc.git
synced 2024-11-24 19:33:59 +08:00
go/types: Remove unused testdata files.
The go/types package was removed in July 2013, but the testdata files were accidentally left behind. From-SVN: r220378
This commit is contained in:
Ian Lance Taylor
parent
2a1d78d8f6
commit
bfdd75a859
302
libgo/go/go/types/testdata/builtins.src
vendored
302
libgo/go/go/types/testdata/builtins.src
vendored
@ -1,302 +0,0 @@
|
||||
// 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 _append() {
|
||||
var x int
|
||||
var s []byte
|
||||
_0 := append /* ERROR "argument" */ ()
|
||||
_1 := append("foo" /* ERROR "not a typed slice" */)
|
||||
_2 := append(nil /* ERROR "not a typed slice" */, s)
|
||||
_3 := append(x /* ERROR "not a typed slice" */, s)
|
||||
_4 := append(s)
|
||||
append /* ERROR "not used" */ (s)
|
||||
}
|
||||
|
||||
func _cap() {
|
||||
var a [10]bool
|
||||
var p *[20]int
|
||||
var s []int
|
||||
var c chan string
|
||||
_0 := cap /* ERROR "argument" */ ()
|
||||
_1 := cap /* ERROR "argument" */ (1, 2)
|
||||
_2 := cap(42 /* ERROR "invalid" */)
|
||||
const _3 = cap(a)
|
||||
assert(_3 == 10)
|
||||
const _4 = cap(p)
|
||||
assert(_4 == 20)
|
||||
_5 := cap(c)
|
||||
cap /* ERROR "not used" */ (c)
|
||||
}
|
||||
|
||||
func _close() {
|
||||
var c chan int
|
||||
var r <-chan int
|
||||
close /* ERROR "argument" */ ()
|
||||
close /* ERROR "argument" */ (1, 2)
|
||||
close(42 /* ERROR "not a channel" */)
|
||||
close(r /* ERROR "receive-only channel" */)
|
||||
close(c)
|
||||
}
|
||||
|
||||
func _complex() {
|
||||
var i32 int32
|
||||
var f32 float32
|
||||
var f64 float64
|
||||
var c64 complex64
|
||||
_ = complex /* ERROR "argument" */ ()
|
||||
_ = complex /* ERROR "argument" */ (1)
|
||||
_ = complex(true /* ERROR "invalid argument" */ , 0)
|
||||
_ = complex(i32 /* ERROR "invalid argument" */ , 0)
|
||||
_ = complex("foo" /* ERROR "invalid argument" */ , 0)
|
||||
_ = complex(c64 /* ERROR "invalid argument" */ , 0)
|
||||
_ = complex(0, true /* ERROR "invalid argument" */ )
|
||||
_ = complex(0, i32 /* ERROR "invalid argument" */ )
|
||||
_ = complex(0, "foo" /* ERROR "invalid argument" */ )
|
||||
_ = complex(0, c64 /* ERROR "invalid argument" */ )
|
||||
_ = 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)
|
||||
}
|
||||
|
||||
func _copy() {
|
||||
copy /* ERROR "not enough arguments" */ ()
|
||||
copy /* ERROR "not enough arguments" */ ("foo")
|
||||
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")
|
||||
}
|
||||
|
||||
func _delete() {
|
||||
var m map[string]int
|
||||
var s string
|
||||
delete /* ERROR "argument" */ ()
|
||||
delete /* ERROR "argument" */ (1)
|
||||
delete /* ERROR "argument" */ (1, 2, 3)
|
||||
delete(m, 0 /* ERROR "not assignable" */)
|
||||
delete(m, s)
|
||||
}
|
||||
|
||||
func _imag() {
|
||||
var f32 float32
|
||||
var f64 float64
|
||||
var c64 complex64
|
||||
var c128 complex128
|
||||
_ = imag /* ERROR "argument" */ ()
|
||||
_ = imag /* ERROR "argument" */ (1, 2)
|
||||
_ = imag(10 /* ERROR "must be a complex number" */)
|
||||
_ = imag(2.7182818 /* ERROR "must be a complex number" */)
|
||||
_ = imag("foo" /* ERROR "must be a complex number" */)
|
||||
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 assign" */ (c128)
|
||||
f64 = imag /* ERROR "cannot assign" */ (c64)
|
||||
imag /* ERROR "not used" */ (c64)
|
||||
}
|
||||
|
||||
func _len() {
|
||||
const c = "foobar"
|
||||
var a [10]bool
|
||||
var p *[20]int
|
||||
var s []int
|
||||
var m map[string]complex128
|
||||
_ = len /* ERROR "argument" */ ()
|
||||
_ = len /* ERROR "argument" */ (1, 2)
|
||||
_ = 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 /* ERROR "failed" */ (n == 10)
|
||||
var ch <-chan int
|
||||
const nn = len /* ERROR "not constant" */ (hash[<-ch][len(t)])
|
||||
_ = nn // TODO(gri) remove this once unused constants get type-checked
|
||||
}
|
||||
|
||||
func _make() {
|
||||
n := 0
|
||||
|
||||
_ = make /* ERROR "argument" */ ()
|
||||
_ = 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 "must be an integer" */)
|
||||
_ = make([]int, 10, 2.3 /* ERROR "must be an integer" */)
|
||||
_ = make([]int, 5, 10.0)
|
||||
_ = make([]int, 0i)
|
||||
_ = 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<<100, 1<<100) // run-time panic
|
||||
_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100 + 1, 1<<100)
|
||||
_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100, 12345)
|
||||
|
||||
// maps
|
||||
_ = make /* ERROR "arguments" */ (map[int]string, 10, 20)
|
||||
_ = make(map[int]float32, int /* ERROR "not an expression" */)
|
||||
_ = make(map[int]float32, "foo" /* ERROR "must be an integer" */)
|
||||
_ = make(map[int]float32, 10)
|
||||
_ = make(map[int]float32, n)
|
||||
_ = make(map[int]float32, int64(n))
|
||||
|
||||
// channels
|
||||
_ = make /* ERROR "arguments" */ (chan int, 10, 20)
|
||||
_ = make(chan int, int /* ERROR "not an expression" */)
|
||||
_ = make(chan<- int, "foo" /* ERROR "must be an integer" */)
|
||||
_ = make(<-chan float64, 10)
|
||||
_ = make(chan chan int, n)
|
||||
_ = make(chan string, int64(n))
|
||||
|
||||
make /* ERROR "not used" */ ([]int, 10)
|
||||
}
|
||||
|
||||
func _new() {
|
||||
_ = new /* ERROR "argument" */ ()
|
||||
_ = new /* ERROR "argument" */ (1, 2)
|
||||
_ = new("foo" /* ERROR "not a type" */)
|
||||
p := new(float64)
|
||||
_ = new(struct{ x, y int })
|
||||
q := new(*float64)
|
||||
_ = *p == **q
|
||||
new /* ERROR "not used" */ (int)
|
||||
}
|
||||
|
||||
func _real() {
|
||||
var f32 float32
|
||||
var f64 float64
|
||||
var c64 complex64
|
||||
var c128 complex128
|
||||
_ = real /* ERROR "argument" */ ()
|
||||
_ = real /* ERROR "argument" */ (1, 2)
|
||||
_ = real(10 /* ERROR "must be a complex number" */)
|
||||
_ = real(2.7182818 /* ERROR "must be a complex number" */)
|
||||
_ = real("foo" /* ERROR "must be a complex number" */)
|
||||
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 assign" */ (c128)
|
||||
f64 = real /* ERROR "cannot assign" */ (c64)
|
||||
real /* ERROR "not used" */ (c64)
|
||||
}
|
||||
|
||||
func _recover() {
|
||||
_ = recover()
|
||||
_ = recover /* ERROR "argument" */ (10)
|
||||
recover()
|
||||
}
|
||||
|
||||
func _Alignof() {
|
||||
var x int
|
||||
_ = unsafe /* ERROR "argument" */ .Alignof()
|
||||
_ = unsafe /* ERROR "argument" */ .Alignof(1, 2)
|
||||
_ = unsafe.Alignof(int /* ERROR "not an expression" */)
|
||||
_ = unsafe.Alignof(42)
|
||||
_ = unsafe.Alignof(new(struct{}))
|
||||
unsafe /* ERROR "not used" */ .Alignof(x)
|
||||
}
|
||||
|
||||
func _Offsetof() {
|
||||
var x struct{ f int }
|
||||
_ = unsafe /* ERROR "argument" */ .Offsetof()
|
||||
_ = unsafe /* ERROR "argument" */ .Offsetof(1, 2)
|
||||
_ = unsafe.Offsetof(int /* ERROR "not an expression" */)
|
||||
_ = unsafe.Offsetof(x /* ERROR "not a selector" */)
|
||||
_ = unsafe.Offsetof(x.f)
|
||||
_ = unsafe.Offsetof((x.f))
|
||||
_ = unsafe.Offsetof((((((((x))).f)))))
|
||||
unsafe /* ERROR "not used" */ .Offsetof(x.f)
|
||||
}
|
||||
|
||||
func _Sizeof() {
|
||||
var x int
|
||||
_ = unsafe /* ERROR "argument" */ .Sizeof()
|
||||
_ = unsafe /* ERROR "argument" */ .Sizeof(1, 2)
|
||||
_ = unsafe.Sizeof(int /* ERROR "not an expression" */)
|
||||
_ = unsafe.Sizeof(42)
|
||||
_ = unsafe.Sizeof(new(complex128))
|
||||
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)
|
||||
}
|
||||
|
||||
// self-testing only
|
||||
func _assert() {
|
||||
var x int
|
||||
assert /* ERROR "argument" */ ()
|
||||
assert /* ERROR "argument" */ (1, 2)
|
||||
assert("foo" /* ERROR "boolean constant" */ )
|
||||
assert(x /* ERROR "boolean constant" */)
|
||||
assert(true)
|
||||
assert /* ERROR "failed" */ (false)
|
||||
}
|
||||
|
||||
// self-testing only
|
||||
func _trace() {
|
||||
// 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")
|
||||
}
|
||||
215
libgo/go/go/types/testdata/const0.src
vendored
215
libgo/go/go/types/testdata/const0.src
vendored
@ -1,215 +0,0 @@
|
||||
// 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
|
||||
|
||||
// constants declarations must be initialized by constants
|
||||
var x = 0
|
||||
const c0 = x /* ERROR "not constant" */
|
||||
|
||||
// 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
|
||||
|
||||
// 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 "cannot compare" */ == 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 // TODO(gri) enable this
|
||||
//ti9 = ti3 % ti3 // TODO(gri) enable this
|
||||
|
||||
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 // TODO(gri) enable this
|
||||
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 "cycle" */ = a
|
||||
b /* ERROR "cycle" */ , c /* ERROR "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
|
||||
_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)
|
||||
)
|
||||
|
||||
// special cases
|
||||
const (
|
||||
_n0 = nil /* ERROR "invalid constant type" */
|
||||
_n1 = [ /* ERROR "not constant" */ ]int{}
|
||||
)
|
||||
18
libgo/go/go/types/testdata/conversions.src
vendored
18
libgo/go/go/types/testdata/conversions.src
vendored
@ -1,18 +0,0 @@
|
||||
// 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
|
||||
|
||||
// argument count
|
||||
var (
|
||||
_v0 = int /* ERROR "one argument" */ ()
|
||||
_v1 = int /* ERROR "one argument" */ (1, 2)
|
||||
)
|
||||
|
||||
//
|
||||
var (
|
||||
_v2 = int8(0)
|
||||
)
|
||||
177
libgo/go/go/types/testdata/decls0.src
vendored
177
libgo/go/go/types/testdata/decls0.src
vendored
@ -1,177 +0,0 @@
|
||||
// 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"
|
||||
// we can have multiple blank imports (was bug)
|
||||
_ "math"
|
||||
_ "net/rpc"
|
||||
)
|
||||
|
||||
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" */ }
|
||||
)
|
||||
|
||||
|
||||
// invalid array types
|
||||
type (
|
||||
iA0 [... /* ERROR "invalid use of '...'" */ ]byte
|
||||
iA1 [1 /* ERROR "invalid array length" */ <<100]int
|
||||
iA2 [- /* ERROR "invalid array length" */ 1]complex128
|
||||
iA3 ["foo" /* ERROR "invalid array length" */ ]string
|
||||
)
|
||||
|
||||
|
||||
type (
|
||||
p1 pi /* ERROR "no single field or method foo" */ .foo
|
||||
p2 unsafe.Pointer
|
||||
)
|
||||
|
||||
|
||||
type (
|
||||
Pi pi /* ERROR "not a type" */
|
||||
|
||||
a /* ERROR "illegal cycle" */ a
|
||||
a /* ERROR "redeclared" */ int
|
||||
|
||||
// where the cycle error appears depends on the
|
||||
// order in which declarations are processed
|
||||
// (which depends on the order in which a map
|
||||
// is iterated through)
|
||||
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 {
|
||||
U // anonymous field
|
||||
// TODO(gri) recognize double-declaration below
|
||||
// U /* 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 { /* ERROR "multiple methods named m1" */
|
||||
m1()
|
||||
m1 /* ERROR "redeclared" */ ()
|
||||
}
|
||||
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
|
||||
}
|
||||
// Use I09 (rather than I9) because it appears lexically before
|
||||
// I10 so that we get the illegal cycle here rather then in the
|
||||
// declaration of I10. If the implementation sorts by position
|
||||
// rather than name, the error message will still be here.
|
||||
I09 /* ERROR "illegal cycle" */ interface {
|
||||
I10
|
||||
}
|
||||
I10 interface {
|
||||
I11
|
||||
}
|
||||
I11 interface {
|
||||
I09
|
||||
}
|
||||
|
||||
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
|
||||
)
|
||||
132
libgo/go/go/types/testdata/decls1.src
vendored
132
libgo/go/go/types/testdata/decls1.src
vendored
@ -1,132 +0,0 @@
|
||||
// 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 "index" */]
|
||||
s8 = &a
|
||||
s10 = &42 /* ERROR "cannot take address" */
|
||||
s11 = &v
|
||||
s12 = -(u + *t11) / *&v
|
||||
s13 = a /* ERROR "shifted operand" */ << d
|
||||
s14 = i << j /* ERROR "must be unsigned" */
|
||||
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 assign" */ )
|
||||
|
||||
t1 int = i + j
|
||||
t2 int = i /* ERROR "mismatched types" */ + x
|
||||
t3 int = c /* ERROR "cannot assign" */ + d
|
||||
t4 string = s + t
|
||||
t5 string = s /* ERROR "invalid operation" */ / t
|
||||
t6 byte = array[t1]
|
||||
t7 byte = array[x /* ERROR "index" */]
|
||||
t8 *int = & /* ERROR "cannot assign" */ 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 /* ERROR "must be unsigned" */
|
||||
t15 math /* ERROR "not in selector" */
|
||||
t16 math.xxx /* ERROR "unexported" */
|
||||
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" */ ()
|
||||
)
|
||||
|
||||
// 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 /* ERROR "assignment count mismatch" */ , ok2, ok3 = iface.(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 + 2147483647
|
||||
v8 = v6 + 2147483648 /* 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 /* ERROR "assignment count mismatch" */ , m2b, m2c = 1, 2
|
||||
m3a /* ERROR "assignment count mismatch" */ , m3b = 1, 2, 3
|
||||
)
|
||||
|
||||
// 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 {}
|
||||
func f4() a /* ERROR "not a type" */ {}
|
||||
func f5() (a, b, c d /* ERROR "not a type" */) {}
|
||||
|
||||
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 {}
|
||||
func (T) init(int) int { return 0 }
|
||||
67
libgo/go/go/types/testdata/decls2a.src
vendored
67
libgo/go/go/types/testdata/decls2a.src
vendored
@ -1,67 +0,0 @@
|
||||
// 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.
|
||||
|
||||
// method declarations
|
||||
|
||||
package decls2
|
||||
|
||||
import "time"
|
||||
|
||||
// T1 declared before its methods.
|
||||
type T1 struct{
|
||||
f int
|
||||
}
|
||||
|
||||
func (T1) m() {}
|
||||
func (T1) m /* ERROR "redeclared" */ () {}
|
||||
func (x *T1) f /* ERROR "field and method" */ () {}
|
||||
|
||||
// T2's method declared before the type.
|
||||
func (*T2) f /* ERROR "field and method" */ () {}
|
||||
|
||||
type T2 struct {
|
||||
f int
|
||||
}
|
||||
|
||||
// Methods declared without a declared type.
|
||||
func (undeclared /* ERROR "undeclared" */) m() {}
|
||||
func (x *undeclared /* ERROR "undeclared" */) m() {}
|
||||
|
||||
// TODO(gri) try to get rid of double error reporting here
|
||||
func (pi /* ERROR "not a type" */) m1() {}
|
||||
func (x pi /* ERROR "not a type" */) m2() {}
|
||||
func (x *pi /* ERROR "not a type" */ ) m3() {} // TODO(gri) not closing the last /* comment crashes the system
|
||||
|
||||
// Blank types.
|
||||
type _ struct { m int }
|
||||
type _ struct { m int }
|
||||
|
||||
// TODO(gri) blank idents not fully checked - disabled for now
|
||||
// func (_ /* ERROR "cannot use _" */) m() {}
|
||||
// func (_ /* ERROR "cannot use _" */) m() {}
|
||||
|
||||
// Methods with receiver base type declared in another file.
|
||||
func (T3) m1() {}
|
||||
func (*T3) m2() {}
|
||||
func (x T3) m3() {}
|
||||
func (x *T3) f /* ERROR "field and method" */ () {}
|
||||
|
||||
// Methods of non-struct type.
|
||||
type T4 func()
|
||||
|
||||
func (self T4) m() func() { return self }
|
||||
|
||||
// Methods associated with an interface.
|
||||
type T5 interface {
|
||||
m() int
|
||||
}
|
||||
|
||||
func (T5 /* ERROR "invalid receiver" */) m1() {}
|
||||
func (T5 /* ERROR "invalid receiver" */) m2() {}
|
||||
|
||||
// Methods associated with non-local or unnamed types.
|
||||
func (int /* ERROR "non-local type" */ ) m() {}
|
||||
func ([ /* ERROR "expected" */ ]int) m() {}
|
||||
func (time /* ERROR "expected" */ .Time) m() {}
|
||||
func (x interface /* ERROR "expected" */ {}) m() {}
|
||||
28
libgo/go/go/types/testdata/decls2b.src
vendored
28
libgo/go/go/types/testdata/decls2b.src
vendored
@ -1,28 +0,0 @@
|
||||
// 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.
|
||||
|
||||
// method declarations
|
||||
|
||||
package decls2
|
||||
|
||||
const pi = 3.1415
|
||||
|
||||
func (T1) m /* ERROR "redeclared" */ () {}
|
||||
|
||||
type T3 struct {
|
||||
f *T3
|
||||
}
|
||||
|
||||
type T6 struct {
|
||||
x int
|
||||
}
|
||||
|
||||
func (t *T6) m1() int {
|
||||
return t.x
|
||||
}
|
||||
|
||||
func f() {
|
||||
var t *T6
|
||||
t.m1()
|
||||
}
|
||||
231
libgo/go/go/types/testdata/decls3.src
vendored
231
libgo/go/go/types/testdata/decls3.src
vendored
@ -1,231 +0,0 @@
|
||||
// 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
|
||||
|
||||
// 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 /* ERROR "no single field or method" */ .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 /* ERROR "no single field or method" */ .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 /* ERROR "no single field or method" */ .X
|
||||
}
|
||||
|
||||
// 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 /* ERROR "no single field or method" */ {}{}.Foo
|
||||
_ = S0{}.A
|
||||
_ = S0 /* ERROR "no single field or method" */ {}.D
|
||||
_ = S1{}.A
|
||||
_ = S1{}.B
|
||||
_ = S1{}.S0
|
||||
_ = S1{}.C
|
||||
_ = S2{}.A
|
||||
_ = S2{}.S1
|
||||
_ = S2{}.B
|
||||
_ = S2{}.C
|
||||
_ = S2 /* ERROR "no single field or method" */ {}.D
|
||||
_ = S3 /* ERROR "no single field or method" */ {}.S1
|
||||
_ = S3{}.A
|
||||
_ = S3 /* ERROR "no single field or method" */ {}.B
|
||||
_ = S3{}.D
|
||||
_ = S3{}.E
|
||||
_ = S4{}.A
|
||||
_ = S4 /* ERROR "no single field or method" */ {}.B
|
||||
_ = S5 /* ERROR "no single field or method" */ {}.X
|
||||
_ = S5{}.Y
|
||||
_ = S10 /* ERROR "no single field or method" */ {}.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 /* ERROR "no single field or method" */ {}.X
|
||||
151
libgo/go/go/types/testdata/expr0.src
vendored
151
libgo/go/go/types/testdata/expr0.src
vendored
@ -1,151 +0,0 @@
|
||||
// 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
|
||||
|
||||
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" */
|
||||
|
||||
// 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 /* ERROR not defined */
|
||||
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 /* ERROR not defined */
|
||||
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 /* ERROR "cannot indirect" */
|
||||
s6 = &s4
|
||||
s7 = *s6
|
||||
s8 = <-s7 /* ERROR "cannot receive" */
|
||||
|
||||
// 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" */
|
||||
)
|
||||
|
||||
// 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" */ ()
|
||||
)
|
||||
7
libgo/go/go/types/testdata/expr1.src
vendored
7
libgo/go/go/types/testdata/expr1.src
vendored
@ -1,7 +0,0 @@
|
||||
// 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
|
||||
23
libgo/go/go/types/testdata/expr2.src
vendored
23
libgo/go/go/types/testdata/expr2.src
vendored
@ -1,23 +0,0 @@
|
||||
// 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
|
||||
_ = struct{b bool}{x < y}
|
||||
}
|
||||
|
||||
// corner cases
|
||||
var (
|
||||
v0 = nil /* ERROR "cannot compare" */ == nil
|
||||
)
|
||||
367
libgo/go/go/types/testdata/expr3.src
vendored
367
libgo/go/go/types/testdata/expr3.src
vendored
@ -1,367 +0,0 @@
|
||||
// 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.
|
||||
|
||||
// various expressions
|
||||
|
||||
package expr3
|
||||
|
||||
func shifts1() {
|
||||
var (
|
||||
i0 int
|
||||
u0 uint
|
||||
)
|
||||
|
||||
var (
|
||||
v0 = 1<<0
|
||||
v1 = 1<<i0 /* ERROR "must be unsigned" */
|
||||
v2 = 1<<u0
|
||||
v3 = 1<<"foo" /* ERROR "must be unsigned" */
|
||||
v4 = 1<<- /* ERROR "stupid shift" */ 1
|
||||
v5 = 1<<1025 /* ERROR "stupid shift" */
|
||||
v6 = 1 /* ERROR "overflows" */ <<100
|
||||
|
||||
v10 uint = 1 << 0
|
||||
v11 uint = 1 << u0
|
||||
v12 float32 = 1 /* ERROR "must be integer" */ << u0
|
||||
)
|
||||
}
|
||||
|
||||
func shifts2() {
|
||||
// TODO(gri) enable commented out tests below.
|
||||
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 != 0 // 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 /* ERROR "overflows" */ <<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
|
||||
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
|
||||
)
|
||||
}
|
||||
|
||||
// TODO(gri) The error messages below depond on adjusting the spec
|
||||
// to reflect what gc is doing at the moment (the spec
|
||||
// asks for run-time errors at the moment - see issue 4231).
|
||||
//
|
||||
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 "must be integer" */ ]
|
||||
_ = a["foo" /* ERROR "must be integer" */ ]
|
||||
_ = a[1.1 /* ERROR "must be integer" */ ]
|
||||
_ = a[1.0]
|
||||
_ = a[- /* ERROR "index .* negative" */ 1]
|
||||
_ = a[- /* ERROR "index .* negative" */ 1 :]
|
||||
_ = a[: - /* ERROR "index .* negative" */ 1]
|
||||
var a0 int
|
||||
a0 = a[0]
|
||||
var a1 int32
|
||||
a1 = a /* ERROR "cannot assign" */ [1]
|
||||
_ = a[9]
|
||||
_ = a[10 /* ERROR "index .* out of bounds" */ ]
|
||||
_ = a[1 /* ERROR "stupid index" */ <<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 "stupid index" */ <<100]
|
||||
|
||||
pa := &a
|
||||
_ = pa[9]
|
||||
_ = pa[10 /* ERROR "index .* out of bounds" */ ]
|
||||
_ = pa[1 /* ERROR "stupid index" */ <<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 "stupid index" */ <<100]
|
||||
|
||||
var b [0]int
|
||||
_ = b[0 /* ERROR "index .* out of bounds" */ ]
|
||||
_ = b[:]
|
||||
_ = b[0:]
|
||||
_ = b[:0]
|
||||
_ = b[0:0]
|
||||
|
||||
var s []int
|
||||
_ = s[- /* ERROR "index .* negative" */ 1]
|
||||
_ = s[- /* ERROR "index .* negative" */ 1 :]
|
||||
_ = s[: - /* ERROR "index .* negative" */ 1]
|
||||
_ = s[0]
|
||||
_ = s[1 : 2]
|
||||
_ = s[2 /* ERROR "inverted slice range" */ : 1]
|
||||
_ = s[2 :]
|
||||
_ = s[: 1 /* ERROR "stupid index" */ <<100]
|
||||
_ = s[1 /* ERROR "stupid index" */ <<100 :]
|
||||
_ = s[1 /* ERROR "stupid index" */ <<100 : 1 /* ERROR "stupid index" */ <<100]
|
||||
|
||||
var t string
|
||||
_ = t[- /* ERROR "index .* negative" */ 1]
|
||||
_ = t[- /* ERROR "index .* negative" */ 1 :]
|
||||
_ = t[: - /* ERROR "index .* negative" */ 1]
|
||||
var t0 byte
|
||||
t0 = t[0]
|
||||
var t1 rune
|
||||
t1 = t /* ERROR "cannot assign" */ [2]
|
||||
_ = ("foo" + "bar")[5]
|
||||
_ = ("foo" + "bar")[6 /* ERROR "index .* out of bounds" */ ]
|
||||
|
||||
const c = "foo"
|
||||
_ = c[- /* ERROR "index .* negative" */ 1]
|
||||
_ = c[- /* ERROR "index .* negative" */ 1 :]
|
||||
_ = c[: - /* ERROR "index .* negative" */ 1]
|
||||
var c0 byte
|
||||
c0 = c[0]
|
||||
var c2 float32
|
||||
c2 = c /* ERROR "cannot assign" */ [2]
|
||||
_ = c[3 /* ERROR "index .* out of bounds" */ ]
|
||||
_ = ""[0 /* ERROR "index .* out of bounds" */ ]
|
||||
|
||||
_ = s[1<<30] // no compile-time error here
|
||||
}
|
||||
|
||||
type T struct {
|
||||
x int
|
||||
}
|
||||
|
||||
func (*T) m() {}
|
||||
|
||||
func method_expressions() {
|
||||
_ = T /* ERROR "no single field or method" */ .a
|
||||
_ = T /* ERROR "has no method" */ .x
|
||||
_ = T.m
|
||||
var f func(*T) = (*T).m
|
||||
var g func(*T) = ( /* ERROR "cannot assign" */ T).m
|
||||
}
|
||||
|
||||
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 use" */ }
|
||||
_ = T1{c /* ERROR "unknown field" */ : 0}
|
||||
_ = T1{T0: { /* ERROR "missing type" */ }}
|
||||
_ = 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 use" */, 3.4 /* ERROR "cannot use" */}
|
||||
}
|
||||
|
||||
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 "index .* 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 "stupid index" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
|
||||
_ = A1{5: 5, 6, 7, 4: 4, 1 /* ERROR "stupid index" */ <<100: 4}
|
||||
_ = A1{2.0}
|
||||
_ = A1{2.1 /* ERROR "cannot use" */ }
|
||||
_ = A1{"foo" /* ERROR "cannot use" */ }
|
||||
|
||||
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 assign" */
|
||||
|
||||
a2 := [...]int{- /* ERROR "index .* negative" */ 1: 0}
|
||||
|
||||
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)
|
||||
|
||||
// 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 "index .* 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 "stupid index" */ <<100: 4, 5 /* ERROR "duplicate index" */ }
|
||||
_ = S0{5: 5, 6, 7, 4: 4, 1 /* ERROR "stupid index" */ <<100: 4}
|
||||
_ = S0{2.0}
|
||||
_ = S0{2.1 /* ERROR "cannot use" */ }
|
||||
_ = S0{"foo" /* ERROR "cannot use" */ }
|
||||
|
||||
// indices must be resolved correctly
|
||||
// (for details, see comment in go/parser/parser.go, method parseElement)
|
||||
index1 := 1
|
||||
_ = S0{index1: 1}
|
||||
_ = S0{index2: 2}
|
||||
_ = S0{index3 /* ERROR "undeclared name" */ : 3}
|
||||
}
|
||||
|
||||
var index2 int = 2
|
||||
|
||||
func map_literals() {
|
||||
type M0 map[string]int
|
||||
|
||||
_ = M0{}
|
||||
_ = M0{1 /* ERROR "missing key" */ }
|
||||
_ = M0{1 /* ERROR "cannot use .* as string key" */ : 2}
|
||||
_ = M0{"foo": "bar" /* ERROR "cannot use .* as int value" */ }
|
||||
_ = M0{"foo": 1, "bar": 2, "foo" /* ERROR "duplicate key" */ : 3 }
|
||||
|
||||
// map keys must be resolved correctly
|
||||
// (for detials, see comment in go/parser/parser.go, method parseElement)
|
||||
key1 := "foo"
|
||||
_ = M0{key1: 1}
|
||||
_ = M0{key2: 2}
|
||||
_ = M0{key3 /* ERROR "undeclared name" */ : 2}
|
||||
}
|
||||
|
||||
var key2 string = "bar"
|
||||
|
||||
type I interface {
|
||||
m()
|
||||
}
|
||||
|
||||
type I2 interface {
|
||||
m(int)
|
||||
}
|
||||
|
||||
type T1 struct{}
|
||||
type T2 struct{}
|
||||
|
||||
func (T2) m(int) {}
|
||||
|
||||
func type_asserts() {
|
||||
var x int
|
||||
_ = x /* ERROR "not an interface" */ .(int)
|
||||
|
||||
var e interface{}
|
||||
var ok bool
|
||||
x, ok = e.(int)
|
||||
|
||||
var t I
|
||||
_ = t /* ERROR "use of .* outside type switch" */ .(type)
|
||||
_ = t.(T)
|
||||
_ = t.(T1 /* ERROR "missing method m" */ )
|
||||
_ = t.(T2 /* ERROR "wrong type for method m" */ )
|
||||
_ = t.(I2 /* ERROR "wrong type for method m" */ )
|
||||
}
|
||||
|
||||
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 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 assign" */ )
|
||||
f1(x ... /* ERROR "cannot use ..." */ )
|
||||
f1(g0 /* ERROR "used as value" */ ())
|
||||
f1(g1())
|
||||
// f1(g2()) // TODO(gri) missing position in error message
|
||||
|
||||
f2 /* ERROR "too few arguments" */ ()
|
||||
f2 /* ERROR "too few arguments" */ (3.14)
|
||||
f2(3.14, "foo")
|
||||
f2(x /* ERROR "cannot assign" */ , "foo")
|
||||
f2(g0 /* ERROR "used as value" */ ())
|
||||
f2 /* ERROR "too few arguments" */ (g1 /* ERROR "cannot assign" */ ())
|
||||
f2(g2())
|
||||
|
||||
fs /* ERROR "too few arguments" */ ()
|
||||
fs(g0 /* ERROR "used as value" */ ())
|
||||
fs(g1 /* ERROR "cannot assign" */ ())
|
||||
// fs(g2()) // TODO(gri) missing position in error message
|
||||
fs(gs())
|
||||
|
||||
fv()
|
||||
fv(1, 2.0, x)
|
||||
fv(s /* ERROR "cannot assign" */ )
|
||||
fv(s...)
|
||||
fv(1, s /* ERROR "can only use ... with matching parameter" */ ...)
|
||||
fv(gs /* ERROR "cannot assign" */ ())
|
||||
fv(gs /* ERROR "cannot assign" */ ()...)
|
||||
|
||||
fi()
|
||||
fi(1, 2.0, x, 3.14, "foo")
|
||||
fi(g2())
|
||||
fi(0, g2)
|
||||
fi(0, g2 /* ERROR "2-valued expression" */ ())
|
||||
}
|
||||
274
libgo/go/go/types/testdata/stmt0.src
vendored
274
libgo/go/go/types/testdata/stmt0.src
vendored
@ -1,274 +0,0 @@
|
||||
// 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 _() {
|
||||
b, i, f, c, s := false, 1, 1.0, 1i, "foo"
|
||||
b = i /* ERROR "cannot assign" */
|
||||
i = f /* ERROR "cannot assign" */
|
||||
f = c /* ERROR "cannot assign" */
|
||||
c = s /* ERROR "cannot assign" */
|
||||
s = b /* ERROR "cannot assign" */
|
||||
|
||||
v0 /* ERROR "mismatch" */, v1, v2 := 1, 2, 3, 4
|
||||
|
||||
b = true
|
||||
|
||||
i += 1
|
||||
i += "foo" /* ERROR "cannot convert.*int" */
|
||||
|
||||
f -= 1
|
||||
f -= "foo" /* ERROR "cannot convert.*float64" */
|
||||
|
||||
c *= 1
|
||||
c /= 0 /* ERROR "division by zero" */
|
||||
|
||||
s += "bar"
|
||||
s += 1 /* ERROR "cannot convert.*string" */
|
||||
}
|
||||
|
||||
func _incdecs() {
|
||||
const c = 3.14
|
||||
c /* ERROR "cannot assign" */ ++
|
||||
s := "foo"
|
||||
s /* ERROR "cannot convert" */ --
|
||||
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 /* ERROR "cannot send" */ <- "foo"
|
||||
ch <- x
|
||||
}
|
||||
|
||||
func _selects() {
|
||||
select {}
|
||||
var (
|
||||
ch chan int
|
||||
sc chan <- bool
|
||||
x int
|
||||
)
|
||||
select {
|
||||
case <-ch:
|
||||
ch <- x
|
||||
case t, ok := <-ch:
|
||||
x = t
|
||||
case <-sc /* ERROR "cannot receive from send-only channel" */ :
|
||||
}
|
||||
select {
|
||||
default:
|
||||
default /* ERROR "multiple defaults" */ :
|
||||
}
|
||||
}
|
||||
|
||||
func _gos() {
|
||||
go 1 /* ERROR "expected function/method call" */
|
||||
go _gos()
|
||||
var c chan int
|
||||
go close(c)
|
||||
go len(c) // TODO(gri) this should not be legal
|
||||
}
|
||||
|
||||
func _defers() {
|
||||
defer 1 /* ERROR "expected function/method call" */
|
||||
defer _defers()
|
||||
var c chan int
|
||||
defer close(c)
|
||||
defer len(c) // TODO(gri) this should not be legal
|
||||
}
|
||||
|
||||
func _switches() {
|
||||
var x int
|
||||
|
||||
switch x {
|
||||
default:
|
||||
default /* ERROR "multiple defaults" */ :
|
||||
}
|
||||
|
||||
switch {
|
||||
case 1 /* ERROR "cannot convert" */ :
|
||||
}
|
||||
|
||||
switch int32(x) {
|
||||
case 1, 2:
|
||||
case x /* ERROR "cannot compare" */ :
|
||||
}
|
||||
|
||||
switch x {
|
||||
case 1 /* ERROR "overflows int" */ << 100:
|
||||
}
|
||||
|
||||
switch x {
|
||||
case 1:
|
||||
case 1 /* ERROR "duplicate case" */ :
|
||||
case 2, 3, 4:
|
||||
case 1 /* ERROR "duplicate case" */ :
|
||||
}
|
||||
|
||||
// TODO(gri) duplicate 64bit values that don't fit into an int64 are not yet detected
|
||||
switch uint64(x) {
|
||||
case 1<<64-1:
|
||||
case 1<<64-1:
|
||||
}
|
||||
}
|
||||
|
||||
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 := x.(type) {}
|
||||
|
||||
switch x := x.(type) {
|
||||
case int:
|
||||
var y int = x
|
||||
}
|
||||
|
||||
switch x := i /* ERROR "not an interface" */ .(type) {}
|
||||
|
||||
switch t := x.(type) {
|
||||
case nil:
|
||||
var v bool = t /* ERROR "cannot assign" */
|
||||
case int:
|
||||
var v int = t
|
||||
case float32, complex64:
|
||||
var v float32 = t /* ERROR "cannot assign" */
|
||||
default:
|
||||
var v float32 = t /* ERROR "cannot assign" */
|
||||
}
|
||||
|
||||
var t I
|
||||
switch t.(type) {
|
||||
case T:
|
||||
case T1 /* ERROR "missing method m" */ :
|
||||
case T2 /* ERROR "wrong type for method m" */ :
|
||||
case I2 /* ERROR "wrong type for method m" */ :
|
||||
}
|
||||
}
|
||||
|
||||
func _rangeloops() {
|
||||
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 i := range x /* ERROR "cannot range over" */ {}
|
||||
|
||||
for i := range a {
|
||||
var ii int
|
||||
ii = i
|
||||
}
|
||||
for i, x := range a {
|
||||
var ii int
|
||||
ii = i
|
||||
var xx float64
|
||||
xx = x /* ERROR "cannot assign" */
|
||||
}
|
||||
var ii int
|
||||
var xx float32
|
||||
for ii, xx := range a {}
|
||||
|
||||
for i := range b {
|
||||
var ii int
|
||||
ii = i
|
||||
}
|
||||
for i, x := range b {
|
||||
var ii int
|
||||
ii = i
|
||||
var xx string
|
||||
xx = x
|
||||
}
|
||||
|
||||
for i := range s {
|
||||
var ii int
|
||||
ii = i
|
||||
}
|
||||
for i, x := range s {
|
||||
var ii int
|
||||
ii = i
|
||||
var xx rune
|
||||
xx = x
|
||||
}
|
||||
|
||||
for _, x := range p {
|
||||
var xx complex128
|
||||
xx = x
|
||||
}
|
||||
|
||||
for _, x := range pp /* ERROR "cannot range over" */ {}
|
||||
|
||||
for k := range m {
|
||||
var kk int32
|
||||
kk = k /* ERROR "cannot assign" */
|
||||
}
|
||||
for k, v := range m {
|
||||
var kk int
|
||||
kk = k
|
||||
if v {}
|
||||
}
|
||||
|
||||
for _, _ /* ERROR "only one iteration variable" */ = range c {}
|
||||
for e := range c {
|
||||
var ee int
|
||||
ee = e
|
||||
}
|
||||
for _ = range sc /* ERROR "cannot range over send-only channel" */ {}
|
||||
for _ = range rc {}
|
||||
|
||||
// constant strings
|
||||
const cs = "foo"
|
||||
for i, x := range cs {}
|
||||
for i, x := range "" {
|
||||
var ii int
|
||||
ii = i
|
||||
var xx rune
|
||||
xx = x
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user