go builtins0 源码
golang builtins0 代码
文件路径：/src/cmd/compile/internal/types2/testdata/check/builtins0.go
// 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 must be a slice */ )
_ = append(nil /* ERROR must be a slice */ , s)
_ = append(x /* ERROR must be 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 not enough arguments */ ...)
_ = append(s, b, s /* ERROR too many arguments */ ... )
_ = append(s, 1, 2, 3)
_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
_ = append(s, 1, 2 /* ERROR too many arguments */ , s... )
_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)
type S []byte
type T string
var t T
_ = append(s, "foo" /* ERROR cannot use .* in argument to append */ )
_ = append(s, "foo"...)
_ = append(S(s), "foo" /* ERROR cannot use .* in argument to append */ )
_ = 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 must be 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 cannot close non-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 cannot use */)
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 := 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 := 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 constant shift overflow */ 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 constant shift overflow */ 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 constant shift overflow */ 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 constant shift overflow */ 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 constant shift overflow */ 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)
}
相关信息
相关文章
0
赞
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
6、 golang
-
8、 openharmony