| // 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" /* ERRORx `cannot use .* in argument to append` */ ) |
| _ = append(s, "foo"...) |
| _ = append(S(s), "foo" /* ERRORx `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 clear1() { |
| var a [10]int |
| var m map[float64]string |
| var s []byte |
| clear(a /* ERROR "cannot clear a" */) |
| clear(&/* ERROR "cannot clear &a" */a) |
| clear(m) |
| clear(s) |
| clear([]int{}) |
| } |
| |
| 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 /* ERRORx `cannot use .* in variable declaration` */ (f64, f64) |
| |
| var _ complex128 = complex /* ERRORx `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 /* ERRORx `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 /* ERRORx `cannot use .* in assignment` */ (c128) |
| f64 = imag /* ERRORx `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 max1() { |
| var b bool |
| var c complex128 |
| var x int |
| var s string |
| type myint int |
| var m myint |
| _ = max() /* ERROR "not enough arguments" */ |
| _ = max(b /* ERROR "cannot be ordered" */ ) |
| _ = max(c /* ERROR "cannot be ordered" */ ) |
| _ = max(x) |
| _ = max(s) |
| _ = max(x, x) |
| _ = max(x, x, x, x, x) |
| var _ int = max /* ERROR "cannot use max(m) (value of type myint) as int value" */ (m) |
| _ = max(x, m /* ERROR "invalid argument: mismatched types int (previous argument) and myint (type of m)" */ , x) |
| |
| _ = max(1, x) |
| _ = max(1.0, x) |
| _ = max(1.2 /* ERROR "1.2 (untyped float constant) truncated to int" */ , x) |
| _ = max(-10, 1.0, c /* ERROR "cannot be ordered" */ ) |
| |
| const ( |
| _ = max /* ERROR "max(x) (value of type int) is not constant" */ (x) |
| _ = max(true /* ERROR "invalid argument: true (untyped bool constant) cannot be ordered" */ ) |
| _ = max(1) |
| _ = max(1, 2.3, 'a') |
| _ = max(1, "foo" /* ERROR "mismatched types" */ ) |
| _ = max(1, 0i /* ERROR "cannot be ordered" */ ) |
| _ = max(1, 2 /* ERROR "cannot be ordered" */ + 3i ) |
| ) |
| } |
| |
| func max2() { |
| _ = assert(max(0) == 0) |
| _ = assert(max(0, 1) == 1) |
| _ = assert(max(0, -10, 123456789) == 123456789) |
| _ = assert(max(-12345678901234567890, 0) == 0) |
| |
| _ = assert(max(1, 2.3) == 2.3) |
| _ = assert(max(1, 2.3, 'a') == 'a') |
| |
| _ = assert(max("", "a") == "a") |
| _ = assert(max("abcde", "xyz", "foo", "bar") == "xyz") |
| |
| const ( |
| _ int = max(1.0) |
| _ float32 = max(1, 2) |
| _ int = max /* ERROR "cannot use max(1, 2.3) (untyped float constant 2.3) as int value" */ (1, 2.3) |
| _ int = max(1.2, 3) // ok! |
| _ byte = max(1, 'a') |
| ) |
| } |
| |
| func min1() { |
| var b bool |
| var c complex128 |
| var x int |
| var s string |
| type myint int |
| var m myint |
| _ = min() /* ERROR "not enough arguments" */ |
| _ = min(b /* ERROR "cannot be ordered" */ ) |
| _ = min(c /* ERROR "cannot be ordered" */ ) |
| _ = min(x) |
| _ = min(s) |
| _ = min(x, x) |
| _ = min(x, x, x, x, x) |
| var _ int = min /* ERROR "cannot use min(m) (value of type myint) as int value" */ (m) |
| _ = min(x, m /* ERROR "invalid argument: mismatched types int (previous argument) and myint (type of m)" */ , x) |
| |
| _ = min(1, x) |
| _ = min(1.0, x) |
| _ = min(1.2 /* ERROR "1.2 (untyped float constant) truncated to int" */ , x) |
| _ = min(-10, 1.0, c /* ERROR "cannot be ordered" */ ) |
| |
| const ( |
| _ = min /* ERROR "min(x) (value of type int) is not constant" */ (x) |
| _ = min(true /* ERROR "invalid argument: true (untyped bool constant) cannot be ordered" */ ) |
| _ = min(1) |
| _ = min(1, 2.3, 'a') |
| _ = min(1, "foo" /* ERROR "mismatched types" */ ) |
| _ = min(1, 0i /* ERROR "cannot be ordered" */ ) |
| _ = min(1, 2 /* ERROR "cannot be ordered" */ + 3i ) |
| ) |
| } |
| |
| func min2() { |
| _ = assert(min(0) == 0) |
| _ = assert(min(0, 1) == 0) |
| _ = assert(min(0, -10, 123456789) == -10) |
| _ = assert(min(-12345678901234567890, 0) == -12345678901234567890) |
| |
| _ = assert(min(1, 2.3) == 1) |
| _ = assert(min(1, 2.3, 'a') == 1) |
| |
| _ = assert(min("", "a") == "") |
| _ = assert(min("abcde", "xyz", "foo", "bar") == "abcde") |
| |
| const ( |
| _ int = min(1.0) |
| _ float32 = min(1, 2) |
| _ int = min(1, 2.3) // ok! |
| _ int = min /* ERROR "cannot use min(1.2, 3) (untyped float constant 1.2) as int value" */ (1.2, 3) |
| _ byte = min(1, 'a') |
| ) |
| } |
| |
| 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 /* ERRORx `cannot use .* in assignment` */ (c128) |
| f64 = real /* ERRORx `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" |
| } |
| |
| func Slice1() { |
| var x int |
| unsafe.Slice() // ERROR "not enough arguments" |
| unsafe.Slice(1, 2, 3) // ERROR "too many arguments" |
| unsafe.Slice(1 /* ERROR "is not a pointer" */ , 2) |
| unsafe.Slice(nil /* ERROR "nil is not a pointer" */ , 0) |
| unsafe.Slice(&x, "foo" /* ERRORx `cannot convert .* to type int` */ ) |
| unsafe.Slice(&x, 1.2 /* ERROR "truncated to int" */ ) |
| unsafe.Slice(&x, - /* ERROR "must not be negative" */ 1) |
| unsafe /* ERROR "not used" */ .Slice(&x, 0) |
| var _ []byte = unsafe /* ERROR "value of type []int" */ .Slice(&x, 0) |
| |
| var _ []int = unsafe.Slice(&x, 0) |
| _ = unsafe.Slice(&x, 1.0) |
| _ = unsafe.Slice((*int)(nil), 0) |
| } |
| |
| func SliceData1() { |
| var s []int |
| unsafe.SliceData(0 /* ERROR "not a slice" */) |
| unsafe /* ERROR "not used" */ .SliceData(s) |
| |
| type S []int |
| _ = unsafe.SliceData(s) |
| _ = unsafe.SliceData(S{}) |
| } |
| |
| func String1() { |
| var b byte |
| unsafe.String() // ERROR "not enough arguments" |
| unsafe.String(1, 2, 3) // ERROR "too many arguments" |
| unsafe.String(1 /* ERROR "cannot use 1" */ , 2) |
| unsafe.String(&b, "foo" /* ERRORx `cannot convert .* to type int` */ ) |
| unsafe.String(&b, 1.2 /* ERROR "truncated to int" */ ) |
| unsafe.String(&b, - /* ERROR "must not be negative" */ 1) |
| unsafe /* ERROR "not used" */ .String(&b, 0) |
| var _ []byte = unsafe /* ERROR "value of type string" */ .String(&b, 0) |
| |
| var _ string = unsafe.String(&b, 0) |
| _ = unsafe.String(&b, 1.0) |
| _ = unsafe.String(nil, 0) // here we allow nil as ptr argument (in contrast to unsafe.Slice) |
| } |
| |
| func StringData1() { |
| var s string |
| type S string |
| unsafe.StringData(0 /* ERROR "cannot use 0" */) |
| unsafe.StringData(S /* ERROR "cannot use S" */ ("foo")) |
| unsafe /* ERROR "not used" */ .StringData(s) |
| |
| _ = unsafe.StringData(s) |
| _ = unsafe.StringData("foo") |
| } |
| |
| // 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) |
| } |