1// Copyright 2012 The Go Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5// builtin calls 6 7package builtins 8 9import "unsafe" 10 11func f0() {} 12 13func append1() { 14 var b byte 15 var x int 16 var s []byte 17 _ = append() // ERROR "not enough arguments" 18 _ = append("foo" /* ERROR "must be a slice" */ ) 19 _ = append(nil /* ERROR "must be a slice" */ , s) 20 _ = append(x /* ERROR "must be a slice" */ , s) 21 _ = append(s) 22 _ = append(s, nil...) 23 append /* ERROR "not used" */ (s) 24 25 _ = append(s, b) 26 _ = append(s, x /* ERROR "cannot use x" */ ) 27 _ = append(s, s /* ERROR "cannot use s" */ ) 28 _ = append(s...) /* ERROR "not enough arguments" */ 29 _ = append(s, b, s /* ERROR "too many arguments" */ ...) 30 _ = append(s, 1, 2, 3) 31 _ = append(s, 1, 2, 3, x /* ERROR "cannot use x" */ , 5, 6, 6) 32 _ = append(s, 1, 2 /* ERROR "too many arguments" */, s...) 33 _ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false) 34 35 type S []byte 36 type T string 37 var t T 38 _ = append(s, "foo" /* ERRORx `cannot use .* in argument to append` */ ) 39 _ = append(s, "foo"...) 40 _ = append(S(s), "foo" /* ERRORx `cannot use .* in argument to append` */ ) 41 _ = append(S(s), "foo"...) 42 _ = append(s, t /* ERROR "cannot use t" */ ) 43 _ = append(s, t...) 44 _ = append(s, T("foo")...) 45 _ = append(S(s), t /* ERROR "cannot use t" */ ) 46 _ = append(S(s), t...) 47 _ = append(S(s), T("foo")...) 48 _ = append([]string{}, t /* ERROR "cannot use t" */ , "foo") 49 _ = append([]T{}, t, "foo") 50} 51 52// from the spec 53func append2() { 54 s0 := []int{0, 0} 55 s1 := append(s0, 2) // append a single element s1 == []int{0, 0, 2} 56 s2 := append(s1, 3, 5, 7) // append multiple elements s2 == []int{0, 0, 2, 3, 5, 7} 57 s3 := append(s2, s0...) // append a slice s3 == []int{0, 0, 2, 3, 5, 7, 0, 0} 58 s4 := append(s3[3:6], s3[2:]...) // append overlapping slice s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0} 59 60 var t []interface{} 61 t = append(t, 42, 3.1415, "foo") // t == []interface{}{42, 3.1415, "foo"} 62 63 var b []byte 64 b = append(b, "bar"...) // append string contents b == []byte{'b', 'a', 'r' } 65 66 _ = s4 67} 68 69func append3() { 70 f1 := func() (s []int) { return } 71 f2 := func() (s []int, x int) { return } 72 f3 := func() (s []int, x, y int) { return } 73 f5 := func() (s []interface{}, x int, y float32, z string, b bool) { return } 74 ff := func() (int, float32) { return 0, 0 } 75 _ = append(f0 /* ERROR "used as value" */ ()) 76 _ = append(f1()) 77 _ = append(f2()) 78 _ = append(f3()) 79 _ = append(f5()) 80 _ = append(ff /* ERROR "must be a slice" */ ()) // TODO(gri) better error message 81} 82 83func cap1() { 84 var a [10]bool 85 var p *[20]int 86 var c chan string 87 _ = cap() // ERROR "not enough arguments" 88 _ = cap(1, 2) // ERROR "too many arguments" 89 _ = cap(42 /* ERROR "invalid" */) 90 const _3 = cap(a) 91 assert(_3 == 10) 92 const _4 = cap(p) 93 assert(_4 == 20) 94 _ = cap(c) 95 cap /* ERROR "not used" */ (c) 96 97 // issue 4744 98 type T struct{ a [10]int } 99 const _ = cap(((*T)(nil)).a) 100 101 var s [][]byte 102 _ = cap(s) 103 _ = cap(s... /* ERROR "invalid use of ... with built-in cap" */ ) 104 105 var x int 106 _ = cap(x /* ERROR "invalid argument: x (variable of type int) for built-in cap" */ ) 107} 108 109func cap2() { 110 f1a := func() (a [10]int) { return } 111 f1s := func() (s []int) { return } 112 f2 := func() (s []int, x int) { return } 113 _ = cap(f0 /* ERROR "used as value" */ ()) 114 _ = cap(f1a()) 115 _ = cap(f1s()) 116 _ = cap(f2()) // ERROR "too many arguments" 117} 118 119// test cases for issue 7387 120func cap3() { 121 var f = func() int { return 0 } 122 var x = f() 123 const ( 124 _ = cap([4]int{}) 125 _ = cap([4]int{x}) 126 _ = cap /* ERROR "not constant" */ ([4]int{f()}) 127 _ = cap /* ERROR "not constant" */ ([4]int{cap([]int{})}) 128 _ = cap([4]int{cap([4]int{})}) 129 ) 130 var y float64 131 var z complex128 132 const ( 133 _ = cap([4]float64{}) 134 _ = cap([4]float64{y}) 135 _ = cap([4]float64{real(2i)}) 136 _ = cap /* ERROR "not constant" */ ([4]float64{real(z)}) 137 ) 138 var ch chan [10]int 139 const ( 140 _ = cap /* ERROR "not constant" */ (<-ch) 141 _ = cap /* ERROR "not constant" */ ([4]int{(<-ch)[0]}) 142 ) 143} 144 145func clear1() { 146 var a [10]int 147 var m map[float64]string 148 var s []byte 149 clear(a /* ERROR "cannot clear a" */) 150 clear(&/* ERROR "cannot clear &a" */a) 151 clear(m) 152 clear(s) 153 clear([]int{}) 154} 155 156func close1() { 157 var c chan int 158 var r <-chan int 159 close() // ERROR "not enough arguments" 160 close(1, 2) // ERROR "too many arguments" 161 close(42 /* ERROR "cannot close non-channel" */) 162 close(r /* ERROR "receive-only channel" */) 163 close(c) 164 _ = close /* ERROR "used as value" */ (c) 165 166 var s []chan int 167 close(s... /* ERROR "invalid use of ..." */ ) 168} 169 170func close2() { 171 f1 := func() (ch chan int) { return } 172 f2 := func() (ch chan int, x int) { return } 173 close(f0 /* ERROR "used as value" */ ()) 174 close(f1()) 175 close(f2()) // ERROR "too many arguments" 176} 177 178func complex1() { 179 var i32 int32 180 var f32 float32 181 var f64 float64 182 var c64 complex64 183 var c128 complex128 184 _ = complex() // ERROR "not enough arguments" 185 _ = complex(1) // ERROR "not enough arguments" 186 _ = complex(true /* ERROR "mismatched types" */ , 0) 187 _ = complex(i32 /* ERROR "expected floating-point" */ , 0) 188 _ = complex("foo" /* ERROR "mismatched types" */ , 0) 189 _ = complex(c64 /* ERROR "expected floating-point" */ , 0) 190 _ = complex(0 /* ERROR "mismatched types" */ , true) 191 _ = complex(0 /* ERROR "expected floating-point" */ , i32) 192 _ = complex(0 /* ERROR "mismatched types" */ , "foo") 193 _ = complex(0 /* ERROR "expected floating-point" */ , c64) 194 _ = complex(f32, f32) 195 _ = complex(f32, 1) 196 _ = complex(f32, 1.0) 197 _ = complex(f32, 'a') 198 _ = complex(f64, f64) 199 _ = complex(f64, 1) 200 _ = complex(f64, 1.0) 201 _ = complex(f64, 'a') 202 _ = complex(f32 /* ERROR "mismatched types" */ , f64) 203 _ = complex(f64 /* ERROR "mismatched types" */ , f32) 204 _ = complex(1, 1) 205 _ = complex(1, 1.1) 206 _ = complex(1, 'a') 207 complex /* ERROR "not used" */ (1, 2) 208 209 var _ complex64 = complex(f32, f32) 210 var _ complex64 = complex /* ERRORx `cannot use .* in variable declaration` */ (f64, f64) 211 212 var _ complex128 = complex /* ERRORx `cannot use .* in variable declaration` */ (f32, f32) 213 var _ complex128 = complex(f64, f64) 214 215 // untyped constants 216 const _ int = complex(1, 0) 217 const _ float32 = complex(1, 0) 218 const _ complex64 = complex(1, 0) 219 const _ complex128 = complex(1, 0) 220 const _ = complex(0i, 0i) 221 const _ = complex(0i, 0) 222 const _ int = 1.0 + complex(1, 0i) 223 224 const _ int = complex /* ERROR "int" */ (1.1, 0) 225 const _ float32 = complex /* ERROR "float32" */ (1, 2) 226 227 // untyped values 228 var s uint 229 _ = complex(1 /* ERROR "integer" */ <<s, 0) 230 const _ = complex /* ERROR "not constant" */ (1 /* ERROR "integer" */ <<s, 0) 231 var _ int = complex /* ERRORx `cannot use .* in variable declaration` */ (1 /* ERROR "integer" */ <<s, 0) 232 233 // floating-point argument types must be identical 234 type F32 float32 235 type F64 float64 236 var x32 F32 237 var x64 F64 238 c64 = complex(x32, x32) 239 _ = complex(x32 /* ERROR "mismatched types" */ , f32) 240 _ = complex(f32 /* ERROR "mismatched types" */ , x32) 241 c128 = complex(x64, x64) 242 _ = c128 243 _ = complex(x64 /* ERROR "mismatched types" */ , f64) 244 _ = complex(f64 /* ERROR "mismatched types" */ , x64) 245 246 var t []float32 247 _ = complex(t... /* ERROR "invalid use of ..." */ ) 248} 249 250func complex2() { 251 f1 := func() (x float32) { return } 252 f2 := func() (x, y float32) { return } 253 f3 := func() (x, y, z float32) { return } 254 _ = complex(f0 /* ERROR "used as value" */ ()) 255 _ = complex(f1()) // ERROR "not enough arguments" 256 _ = complex(f2()) 257 _ = complex(f3()) // ERROR "too many arguments" 258} 259 260func copy1() { 261 copy() // ERROR "not enough arguments" 262 copy("foo") // ERROR "not enough arguments" 263 copy([ /* ERROR "copy expects slice arguments" */ ...]int{}, []int{}) 264 copy([ /* ERROR "copy expects slice arguments" */ ]int{}, [...]int{}) 265 copy([ /* ERROR "different element types" */ ]int8{}, "foo") 266 267 // spec examples 268 var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7} 269 var s = make([]int, 6) 270 var b = make([]byte, 5) 271 n1 := copy(s, a[0:]) // n1 == 6, s == []int{0, 1, 2, 3, 4, 5} 272 n2 := copy(s, s[2:]) // n2 == 4, s == []int{2, 3, 4, 5, 4, 5} 273 n3 := copy(b, "Hello, World!") // n3 == 5, b == []byte("Hello") 274 _, _, _ = n1, n2, n3 275 276 var t [][]int 277 copy(t, t) 278 copy(t /* ERROR "copy expects slice arguments" */ , nil) 279 copy(nil /* ERROR "copy expects slice arguments" */ , t) 280 copy(nil /* ERROR "copy expects slice arguments" */ , nil) 281 copy(t... /* ERROR "invalid use of ..." */ ) 282} 283 284func copy2() { 285 f1 := func() (a []int) { return } 286 f2 := func() (a, b []int) { return } 287 f3 := func() (a, b, c []int) { return } 288 copy(f0 /* ERROR "used as value" */ ()) 289 copy(f1()) // ERROR "not enough arguments" 290 copy(f2()) 291 copy(f3()) // ERROR "too many arguments" 292} 293 294func delete1() { 295 var m map[string]int 296 var s string 297 delete() // ERROR "not enough arguments" 298 delete(1) // ERROR "not enough arguments" 299 delete(1, 2, 3) // ERROR "too many arguments" 300 delete(m, 0 /* ERROR "cannot use" */) 301 delete(m, s) 302 _ = delete /* ERROR "used as value" */ (m, s) 303 304 var t []map[string]string 305 delete(t... /* ERROR "invalid use of ..." */ ) 306} 307 308func delete2() { 309 f1 := func() (m map[string]int) { return } 310 f2 := func() (m map[string]int, k string) { return } 311 f3 := func() (m map[string]int, k string, x float32) { return } 312 delete(f0 /* ERROR "used as value" */ ()) 313 delete(f1()) // ERROR "not enough arguments" 314 delete(f2()) 315 delete(f3()) // ERROR "too many arguments" 316} 317 318func imag1() { 319 var f32 float32 320 var f64 float64 321 var c64 complex64 322 var c128 complex128 323 _ = imag() // ERROR "not enough arguments" 324 _ = imag(1, 2) // ERROR "too many arguments" 325 _ = imag(10) 326 _ = imag(2.7182818) 327 _ = imag("foo" /* ERROR "expected complex" */) 328 _ = imag('a') 329 const _5 = imag(1 + 2i) 330 assert(_5 == 2) 331 f32 = _5 332 f64 = _5 333 const _6 = imag(0i) 334 assert(_6 == 0) 335 f32 = imag(c64) 336 f64 = imag(c128) 337 f32 = imag /* ERRORx `cannot use .* in assignment` */ (c128) 338 f64 = imag /* ERRORx `cannot use .* in assignment` */ (c64) 339 imag /* ERROR "not used" */ (c64) 340 _, _ = f32, f64 341 342 // complex type may not be predeclared 343 type C64 complex64 344 type C128 complex128 345 var x64 C64 346 var x128 C128 347 f32 = imag(x64) 348 f64 = imag(x128) 349 350 var a []complex64 351 _ = imag(a... /* ERROR "invalid use of ..." */ ) 352 353 // if argument is untyped, result is untyped 354 const _ byte = imag(1.2 + 3i) 355 const _ complex128 = imag(1.2 + 3i) 356 357 // lhs constant shift operands are typed as complex128 358 var s uint 359 _ = imag(1 /* ERROR "must be integer" */ << s) 360} 361 362func imag2() { 363 f1 := func() (x complex128) { return } 364 f2 := func() (x, y complex128) { return } 365 _ = imag(f0 /* ERROR "used as value" */ ()) 366 _ = imag(f1()) 367 _ = imag(f2()) // ERROR "too many arguments" 368} 369 370func len1() { 371 const c = "foobar" 372 var a [10]bool 373 var p *[20]int 374 var m map[string]complex128 375 _ = len() // ERROR "not enough arguments" 376 _ = len(1, 2) // ERROR "too many arguments" 377 _ = len(42 /* ERROR "invalid" */) 378 const _3 = len(c) 379 assert(_3 == 6) 380 const _4 = len(a) 381 assert(_4 == 10) 382 const _5 = len(p) 383 assert(_5 == 20) 384 _ = len(m) 385 len /* ERROR "not used" */ (c) 386 387 // esoteric case 388 var t string 389 var hash map[interface{}][]*[10]int 390 const n = len /* ERROR "not constant" */ (hash[recover()][len(t)]) 391 assert(n == 10) // ok because n has unknown value and no error is reported 392 var ch <-chan int 393 const nn = len /* ERROR "not constant" */ (hash[<-ch][len(t)]) 394 395 // issue 4744 396 type T struct{ a [10]int } 397 const _ = len(((*T)(nil)).a) 398 399 var s [][]byte 400 _ = len(s) 401 _ = len(s... /* ERROR "invalid use of ..." */ ) 402} 403 404func len2() { 405 f1 := func() (x []int) { return } 406 f2 := func() (x, y []int) { return } 407 _ = len(f0 /* ERROR "used as value" */ ()) 408 _ = len(f1()) 409 _ = len(f2()) // ERROR "too many arguments" 410} 411 412// test cases for issue 7387 413func len3() { 414 var f = func() int { return 0 } 415 var x = f() 416 const ( 417 _ = len([4]int{}) 418 _ = len([4]int{x}) 419 _ = len /* ERROR "not constant" */ ([4]int{f()}) 420 _ = len /* ERROR "not constant" */ ([4]int{len([]int{})}) 421 _ = len([4]int{len([4]int{})}) 422 ) 423 var y float64 424 var z complex128 425 const ( 426 _ = len([4]float64{}) 427 _ = len([4]float64{y}) 428 _ = len([4]float64{real(2i)}) 429 _ = len /* ERROR "not constant" */ ([4]float64{real(z)}) 430 ) 431 var ch chan [10]int 432 const ( 433 _ = len /* ERROR "not constant" */ (<-ch) 434 _ = len /* ERROR "not constant" */ ([4]int{(<-ch)[0]}) 435 ) 436} 437 438func make1() { 439 var n int 440 var m float32 441 var s uint 442 443 _ = make() // ERROR "not enough arguments" 444 _ = make(1 /* ERROR "not a type" */) 445 _ = make(int /* ERROR "cannot make" */) 446 447 // slices 448 _ = make/* ERROR "arguments" */ ([]int) 449 _ = make/* ERROR "arguments" */ ([]int, 2, 3, 4) 450 _ = make([]int, int /* ERROR "not an expression" */) 451 _ = make([]int, 10, float32 /* ERROR "not an expression" */) 452 _ = make([]int, "foo" /* ERROR "cannot convert" */) 453 _ = make([]int, 10, 2.3 /* ERROR "truncated" */) 454 _ = make([]int, 5, 10.0) 455 _ = make([]int, 0i) 456 _ = make([]int, 1.0) 457 _ = make([]int, 1.0<<s) 458 _ = make([]int, 1.1 /* ERROR "int" */ <<s) 459 _ = make([]int, - /* ERROR "must not be negative" */ 1, 10) 460 _ = make([]int, 0, - /* ERROR "must not be negative" */ 1) 461 _ = make([]int, - /* ERROR "must not be negative" */ 1, - /* ERROR "must not be negative" */ 1) 462 _ = make([]int, 1 /* ERROR "overflows" */ <<100, 1 /* ERROR "overflows" */ <<100) 463 _ = make([]int, 10 /* ERROR "length and capacity swapped" */ , 9) 464 _ = make([]int, 1 /* ERROR "overflows" */ <<100, 12345) 465 _ = make([]int, m /* ERROR "must be integer" */ ) 466 _ = &make /* ERROR "cannot take address" */ ([]int, 0) 467 468 // maps 469 _ = make /* ERROR "arguments" */ (map[int]string, 10, 20) 470 _ = make(map[int]float32, int /* ERROR "not an expression" */) 471 _ = make(map[int]float32, "foo" /* ERROR "cannot convert" */) 472 _ = make(map[int]float32, 10) 473 _ = make(map[int]float32, n) 474 _ = make(map[int]float32, int64(n)) 475 _ = make(map[string]bool, 10.0) 476 _ = make(map[string]bool, 10.0<<s) 477 _ = &make /* ERROR "cannot take address" */ (map[string]bool) 478 479 // channels 480 _ = make /* ERROR "arguments" */ (chan int, 10, 20) 481 _ = make(chan int, int /* ERROR "not an expression" */) 482 _ = make(chan<- int, "foo" /* ERROR "cannot convert" */) 483 _ = make(chan int, - /* ERROR "must not be negative" */ 10) 484 _ = make(<-chan float64, 10) 485 _ = make(chan chan int, n) 486 _ = make(chan string, int64(n)) 487 _ = make(chan bool, 10.0) 488 _ = make(chan bool, 10.0<<s) 489 _ = &make /* ERROR "cannot take address" */ (chan bool) 490 491 make /* ERROR "not used" */ ([]int, 10) 492 493 var t []int 494 _ = make([]int, t[0], t[1]) 495 _ = make([]int, t... /* ERROR "invalid use of ..." */ ) 496} 497 498func make2() { 499 f1 := func() (x []int) { return } 500 _ = make(f0 /* ERROR "not a type" */ ()) 501 _ = make(f1 /* ERROR "not a type" */ ()) 502} 503 504func max1() { 505 var b bool 506 var c complex128 507 var x int 508 var s string 509 type myint int 510 var m myint 511 _ = max() /* ERROR "not enough arguments" */ 512 _ = max(b /* ERROR "cannot be ordered" */ ) 513 _ = max(c /* ERROR "cannot be ordered" */ ) 514 _ = max(x) 515 _ = max(s) 516 _ = max(x, x) 517 _ = max(x, x, x, x, x) 518 var _ int = max /* ERROR "cannot use max(m) (value of type myint) as int value" */ (m) 519 _ = max(x, m /* ERROR "invalid argument: mismatched types int (previous argument) and myint (type of m)" */ , x) 520 521 _ = max(1, x) 522 _ = max(1.0, x) 523 _ = max(1.2 /* ERROR "1.2 (untyped float constant) truncated to int" */ , x) 524 _ = max(-10, 1.0, c /* ERROR "cannot be ordered" */ ) 525 526 const ( 527 _ = max /* ERROR "max(x) (value of type int) is not constant" */ (x) 528 _ = max(true /* ERROR "invalid argument: true (untyped bool constant) cannot be ordered" */ ) 529 _ = max(1) 530 _ = max(1, 2.3, 'a') 531 _ = max(1, "foo" /* ERROR "mismatched types" */ ) 532 _ = max(1, 0i /* ERROR "cannot be ordered" */ ) 533 _ = max(1, 2 /* ERROR "cannot be ordered" */ + 3i ) 534 ) 535} 536 537func max2() { 538 _ = assert(max(0) == 0) 539 _ = assert(max(0, 1) == 1) 540 _ = assert(max(0, -10, 123456789) == 123456789) 541 _ = assert(max(-12345678901234567890, 0) == 0) 542 543 _ = assert(max(1, 2.3) == 2.3) 544 _ = assert(max(1, 2.3, 'a') == 'a') 545 546 _ = assert(max("", "a") == "a") 547 _ = assert(max("abcde", "xyz", "foo", "bar") == "xyz") 548 549 const ( 550 _ int = max(1.0) 551 _ float32 = max(1, 2) 552 _ int = max /* ERROR "cannot use max(1, 2.3) (untyped float constant 2.3) as int value" */ (1, 2.3) 553 _ int = max(1.2, 3) // ok! 554 _ byte = max(1, 'a') 555 ) 556} 557 558func min1() { 559 var b bool 560 var c complex128 561 var x int 562 var s string 563 type myint int 564 var m myint 565 _ = min() /* ERROR "not enough arguments" */ 566 _ = min(b /* ERROR "cannot be ordered" */ ) 567 _ = min(c /* ERROR "cannot be ordered" */ ) 568 _ = min(x) 569 _ = min(s) 570 _ = min(x, x) 571 _ = min(x, x, x, x, x) 572 var _ int = min /* ERROR "cannot use min(m) (value of type myint) as int value" */ (m) 573 _ = min(x, m /* ERROR "invalid argument: mismatched types int (previous argument) and myint (type of m)" */ , x) 574 575 _ = min(1, x) 576 _ = min(1.0, x) 577 _ = min(1.2 /* ERROR "1.2 (untyped float constant) truncated to int" */ , x) 578 _ = min(-10, 1.0, c /* ERROR "cannot be ordered" */ ) 579 580 const ( 581 _ = min /* ERROR "min(x) (value of type int) is not constant" */ (x) 582 _ = min(true /* ERROR "invalid argument: true (untyped bool constant) cannot be ordered" */ ) 583 _ = min(1) 584 _ = min(1, 2.3, 'a') 585 _ = min(1, "foo" /* ERROR "mismatched types" */ ) 586 _ = min(1, 0i /* ERROR "cannot be ordered" */ ) 587 _ = min(1, 2 /* ERROR "cannot be ordered" */ + 3i ) 588 ) 589} 590 591func min2() { 592 _ = assert(min(0) == 0) 593 _ = assert(min(0, 1) == 0) 594 _ = assert(min(0, -10, 123456789) == -10) 595 _ = assert(min(-12345678901234567890, 0) == -12345678901234567890) 596 597 _ = assert(min(1, 2.3) == 1) 598 _ = assert(min(1, 2.3, 'a') == 1) 599 600 _ = assert(min("", "a") == "") 601 _ = assert(min("abcde", "xyz", "foo", "bar") == "abcde") 602 603 const ( 604 _ int = min(1.0) 605 _ float32 = min(1, 2) 606 _ int = min(1, 2.3) // ok! 607 _ int = min /* ERROR "cannot use min(1.2, 3) (untyped float constant 1.2) as int value" */ (1.2, 3) 608 _ byte = min(1, 'a') 609 ) 610} 611 612func new1() { 613 _ = new() // ERROR "not enough arguments" 614 _ = new(1, 2) // ERROR "too many arguments" 615 _ = new("foo" /* ERROR "not a type" */) 616 p := new(float64) 617 _ = new(struct{ x, y int }) 618 q := new(*float64) 619 _ = *p == **q 620 new /* ERROR "not used" */ (int) 621 _ = &new /* ERROR "cannot take address" */ (int) 622 623 _ = new(int... /* ERROR "invalid use of ..." */ ) 624} 625 626func new2() { 627 f1 := func() (x []int) { return } 628 _ = new(f0 /* ERROR "not a type" */ ()) 629 _ = new(f1 /* ERROR "not a type" */ ()) 630} 631 632func panic1() { 633 panic() // ERROR "not enough arguments" 634 panic(1, 2) // ERROR "too many arguments" 635 panic(0) 636 panic("foo") 637 panic(false) 638 panic(1<<10) 639 panic(1 << /* ERROR "constant shift overflow" */ 1000) 640 _ = panic /* ERROR "used as value" */ (0) 641 642 var s []byte 643 panic(s) 644 panic(s... /* ERROR "invalid use of ..." */ ) 645} 646 647func panic2() { 648 f1 := func() (x int) { return } 649 f2 := func() (x, y int) { return } 650 panic(f0 /* ERROR "used as value" */ ()) 651 panic(f1()) 652 panic(f2()) // ERROR "too many arguments" 653} 654 655func print1() { 656 print() 657 print(1) 658 print(1, 2) 659 print("foo") 660 print(2.718281828) 661 print(false) 662 print(1<<10) 663 print(1 << /* ERROR "constant shift overflow" */ 1000) 664 println(nil /* ERROR "untyped nil" */ ) 665 666 var s []int 667 print(s... /* ERROR "invalid use of ..." */ ) 668 _ = print /* ERROR "used as value" */ () 669} 670 671func print2() { 672 f1 := func() (x int) { return } 673 f2 := func() (x, y int) { return } 674 f3 := func() (x int, y float32, z string) { return } 675 print(f0 /* ERROR "used as value" */ ()) 676 print(f1()) 677 print(f2()) 678 print(f3()) 679} 680 681func println1() { 682 println() 683 println(1) 684 println(1, 2) 685 println("foo") 686 println(2.718281828) 687 println(false) 688 println(1<<10) 689 println(1 << /* ERROR "constant shift overflow" */ 1000) 690 println(nil /* ERROR "untyped nil" */ ) 691 692 var s []int 693 println(s... /* ERROR "invalid use of ..." */ ) 694 _ = println /* ERROR "used as value" */ () 695} 696 697func println2() { 698 f1 := func() (x int) { return } 699 f2 := func() (x, y int) { return } 700 f3 := func() (x int, y float32, z string) { return } 701 println(f0 /* ERROR "used as value" */ ()) 702 println(f1()) 703 println(f2()) 704 println(f3()) 705} 706 707func real1() { 708 var f32 float32 709 var f64 float64 710 var c64 complex64 711 var c128 complex128 712 _ = real() // ERROR "not enough arguments" 713 _ = real(1, 2) // ERROR "too many arguments" 714 _ = real(10) 715 _ = real(2.7182818) 716 _ = real("foo" /* ERROR "expected complex" */) 717 const _5 = real(1 + 2i) 718 assert(_5 == 1) 719 f32 = _5 720 f64 = _5 721 const _6 = real(0i) 722 assert(_6 == 0) 723 f32 = real(c64) 724 f64 = real(c128) 725 f32 = real /* ERRORx `cannot use .* in assignment` */ (c128) 726 f64 = real /* ERRORx `cannot use .* in assignment` */ (c64) 727 real /* ERROR "not used" */ (c64) 728 729 // complex type may not be predeclared 730 type C64 complex64 731 type C128 complex128 732 var x64 C64 733 var x128 C128 734 f32 = imag(x64) 735 f64 = imag(x128) 736 _, _ = f32, f64 737 738 var a []complex64 739 _ = real(a... /* ERROR "invalid use of ..." */ ) 740 741 // if argument is untyped, result is untyped 742 const _ byte = real(1 + 2.3i) 743 const _ complex128 = real(1 + 2.3i) 744 745 // lhs constant shift operands are typed as complex128 746 var s uint 747 _ = real(1 /* ERROR "must be integer" */ << s) 748} 749 750func real2() { 751 f1 := func() (x complex128) { return } 752 f2 := func() (x, y complex128) { return } 753 _ = real(f0 /* ERROR "used as value" */ ()) 754 _ = real(f1()) 755 _ = real(f2()) // ERROR "too many arguments" 756} 757 758func recover1() { 759 _ = recover() 760 _ = recover(10) // ERROR "too many arguments" 761 recover() 762 763 var s []int 764 recover(s... /* ERROR "invalid use of ..." */ ) 765} 766 767func recover2() { 768 f1 := func() (x int) { return } 769 f2 := func() (x, y int) { return } 770 _ = recover(f0 /* ERROR "used as value" */ ()) 771 _ = recover(f1()) // ERROR "too many arguments" 772 _ = recover(f2()) // ERROR "too many arguments" 773} 774 775// assuming types.DefaultPtrSize == 8 776type S0 struct{ // offset 777 a bool // 0 778 b rune // 4 779 c *int // 8 780 d bool // 16 781 e complex128 // 24 782} // 40 783 784type S1 struct{ // offset 785 x float32 // 0 786 y string // 8 787 z *S1 // 24 788 S0 // 32 789} // 72 790 791type S2 struct{ // offset 792 *S1 // 0 793} // 8 794 795type S3 struct { // offset 796 a int64 // 0 797 b int32 // 8 798} // 16 799 800type S4 struct { // offset 801 S3 // 0 802 int32 // 12 803} // 24 804 805type S5 struct { // offset 806 a [3]int32 // 0 807 b int32 // 16 808} // 16 809 810func (S2) m() {} 811 812func Alignof1() { 813 var x int 814 _ = unsafe.Alignof() // ERROR "not enough arguments" 815 _ = unsafe.Alignof(1, 2) // ERROR "too many arguments" 816 _ = unsafe.Alignof(int /* ERROR "not an expression" */) 817 _ = unsafe.Alignof(42) 818 _ = unsafe.Alignof(new(struct{})) 819 _ = unsafe.Alignof(1<<10) 820 _ = unsafe.Alignof(1 << /* ERROR "constant shift overflow" */ 1000) 821 _ = unsafe.Alignof(nil /* ERROR "untyped nil" */ ) 822 unsafe /* ERROR "not used" */ .Alignof(x) 823 824 var y S0 825 assert(unsafe.Alignof(y.a) == 1) 826 assert(unsafe.Alignof(y.b) == 4) 827 assert(unsafe.Alignof(y.c) == 8) 828 assert(unsafe.Alignof(y.d) == 1) 829 assert(unsafe.Alignof(y.e) == 8) 830 831 var s []byte 832 _ = unsafe.Alignof(s) 833 _ = unsafe.Alignof(s... /* ERROR "invalid use of ..." */ ) 834} 835 836func Alignof2() { 837 f1 := func() (x int32) { return } 838 f2 := func() (x, y int32) { return } 839 _ = unsafe.Alignof(f0 /* ERROR "used as value" */ ()) 840 assert(unsafe.Alignof(f1()) == 4) 841 _ = unsafe.Alignof(f2()) // ERROR "too many arguments" 842} 843 844func Offsetof1() { 845 var x struct{ f int } 846 _ = unsafe.Offsetof() // ERROR "not enough arguments" 847 _ = unsafe.Offsetof(1, 2) // ERROR "too many arguments" 848 _ = unsafe.Offsetof(int /* ERROR "not a selector expression" */ ) 849 _ = unsafe.Offsetof(x /* ERROR "not a selector expression" */ ) 850 _ = unsafe.Offsetof(nil /* ERROR "not a selector expression" */ ) 851 _ = unsafe.Offsetof(x.f) 852 _ = unsafe.Offsetof((x.f)) 853 _ = unsafe.Offsetof((((((((x))).f))))) 854 unsafe /* ERROR "not used" */ .Offsetof(x.f) 855 856 var y0 S0 857 assert(unsafe.Offsetof(y0.a) == 0) 858 assert(unsafe.Offsetof(y0.b) == 4) 859 assert(unsafe.Offsetof(y0.c) == 8) 860 assert(unsafe.Offsetof(y0.d) == 16) 861 assert(unsafe.Offsetof(y0.e) == 24) 862 863 var y1 S1 864 assert(unsafe.Offsetof(y1.x) == 0) 865 assert(unsafe.Offsetof(y1.y) == 8) 866 assert(unsafe.Offsetof(y1.z) == 24) 867 assert(unsafe.Offsetof(y1.S0) == 32) 868 869 assert(unsafe.Offsetof(y1.S0.a) == 0) // relative to S0 870 assert(unsafe.Offsetof(y1.a) == 32) // relative to S1 871 assert(unsafe.Offsetof(y1.b) == 36) // relative to S1 872 assert(unsafe.Offsetof(y1.c) == 40) // relative to S1 873 assert(unsafe.Offsetof(y1.d) == 48) // relative to S1 874 assert(unsafe.Offsetof(y1.e) == 56) // relative to S1 875 876 var y1p *S1 877 assert(unsafe.Offsetof(y1p.S0) == 32) 878 879 type P *S1 880 var p P = y1p 881 assert(unsafe.Offsetof(p.S0) == 32) 882 883 var y2 S2 884 assert(unsafe.Offsetof(y2.S1) == 0) 885 _ = unsafe.Offsetof(y2 /* ERROR "embedded via a pointer" */ .x) 886 _ = unsafe.Offsetof(y2 /* ERROR "method value" */ .m) 887 888 var s []byte 889 _ = unsafe.Offsetof(s... /* ERROR "invalid use of ..." */ ) 890} 891 892func Offsetof2() { 893 f1 := func() (x int32) { return } 894 f2 := func() (x, y int32) { return } 895 _ = unsafe.Offsetof(f0 /* ERROR "not a selector expression" */ ()) 896 _ = unsafe.Offsetof(f1 /* ERROR "not a selector expression" */ ()) 897 _ = unsafe.Offsetof(f2 /* ERROR "not a selector expression" */ ()) 898} 899 900func Sizeof1() { 901 var x int 902 _ = unsafe.Sizeof() // ERROR "not enough arguments" 903 _ = unsafe.Sizeof(1, 2) // ERROR "too many arguments" 904 _ = unsafe.Sizeof(int /* ERROR "not an expression" */) 905 _ = unsafe.Sizeof(42) 906 _ = unsafe.Sizeof(new(complex128)) 907 _ = unsafe.Sizeof(1<<10) 908 _ = unsafe.Sizeof(1 << /* ERROR "constant shift overflow" */ 1000) 909 _ = unsafe.Sizeof(nil /* ERROR "untyped nil" */ ) 910 unsafe /* ERROR "not used" */ .Sizeof(x) 911 912 // basic types have size guarantees 913 assert(unsafe.Sizeof(byte(0)) == 1) 914 assert(unsafe.Sizeof(uint8(0)) == 1) 915 assert(unsafe.Sizeof(int8(0)) == 1) 916 assert(unsafe.Sizeof(uint16(0)) == 2) 917 assert(unsafe.Sizeof(int16(0)) == 2) 918 assert(unsafe.Sizeof(uint32(0)) == 4) 919 assert(unsafe.Sizeof(int32(0)) == 4) 920 assert(unsafe.Sizeof(float32(0)) == 4) 921 assert(unsafe.Sizeof(uint64(0)) == 8) 922 assert(unsafe.Sizeof(int64(0)) == 8) 923 assert(unsafe.Sizeof(float64(0)) == 8) 924 assert(unsafe.Sizeof(complex64(0)) == 8) 925 assert(unsafe.Sizeof(complex128(0)) == 16) 926 927 var y0 S0 928 assert(unsafe.Sizeof(y0.a) == 1) 929 assert(unsafe.Sizeof(y0.b) == 4) 930 assert(unsafe.Sizeof(y0.c) == 8) 931 assert(unsafe.Sizeof(y0.d) == 1) 932 assert(unsafe.Sizeof(y0.e) == 16) 933 assert(unsafe.Sizeof(y0) == 40) 934 935 var y1 S1 936 assert(unsafe.Sizeof(y1) == 72) 937 938 var y2 S2 939 assert(unsafe.Sizeof(y2) == 8) 940 941 var y3 S3 942 assert(unsafe.Sizeof(y3) == 16) 943 944 var y4 S4 945 assert(unsafe.Sizeof(y4) == 24) 946 947 var y5 S5 948 assert(unsafe.Sizeof(y5) == 16) 949 950 var a3 [10]S3 951 assert(unsafe.Sizeof(a3) == 160) 952 953 // test case for issue 5670 954 type T struct { 955 a int32 956 _ int32 957 c int32 958 } 959 assert(unsafe.Sizeof(T{}) == 12) 960 961 var s []byte 962 _ = unsafe.Sizeof(s) 963 _ = unsafe.Sizeof(s... /* ERROR "invalid use of ..." */ ) 964} 965 966func Sizeof2() { 967 f1 := func() (x int64) { return } 968 f2 := func() (x, y int64) { return } 969 _ = unsafe.Sizeof(f0 /* ERROR "used as value" */ ()) 970 assert(unsafe.Sizeof(f1()) == 8) 971 _ = unsafe.Sizeof(f2()) // ERROR "too many arguments" 972} 973 974func Slice1() { 975 var x int 976 unsafe.Slice() // ERROR "not enough arguments" 977 unsafe.Slice(1, 2, 3) // ERROR "too many arguments" 978 unsafe.Slice(1 /* ERROR "is not a pointer" */ , 2) 979 unsafe.Slice(nil /* ERROR "nil is not a pointer" */ , 0) 980 unsafe.Slice(&x, "foo" /* ERRORx `cannot convert .* to type int` */ ) 981 unsafe.Slice(&x, 1.2 /* ERROR "truncated to int" */ ) 982 unsafe.Slice(&x, - /* ERROR "must not be negative" */ 1) 983 unsafe /* ERROR "not used" */ .Slice(&x, 0) 984 var _ []byte = unsafe /* ERROR "value of type []int" */ .Slice(&x, 0) 985 986 var _ []int = unsafe.Slice(&x, 0) 987 _ = unsafe.Slice(&x, 1.0) 988 _ = unsafe.Slice((*int)(nil), 0) 989} 990 991func SliceData1() { 992 var s []int 993 unsafe.SliceData(0 /* ERROR "not a slice" */) 994 unsafe /* ERROR "not used" */ .SliceData(s) 995 996 type S []int 997 _ = unsafe.SliceData(s) 998 _ = unsafe.SliceData(S{}) 999} 1000 1001func String1() { 1002 var b byte 1003 unsafe.String() // ERROR "not enough arguments" 1004 unsafe.String(1, 2, 3) // ERROR "too many arguments" 1005 unsafe.String(1 /* ERROR "cannot use 1" */ , 2) 1006 unsafe.String(&b, "foo" /* ERRORx `cannot convert .* to type int` */ ) 1007 unsafe.String(&b, 1.2 /* ERROR "truncated to int" */ ) 1008 unsafe.String(&b, - /* ERROR "must not be negative" */ 1) 1009 unsafe /* ERROR "not used" */ .String(&b, 0) 1010 var _ []byte = unsafe /* ERROR "value of type string" */ .String(&b, 0) 1011 1012 var _ string = unsafe.String(&b, 0) 1013 _ = unsafe.String(&b, 1.0) 1014 _ = unsafe.String(nil, 0) // here we allow nil as ptr argument (in contrast to unsafe.Slice) 1015} 1016 1017func StringData1() { 1018 var s string 1019 type S string 1020 unsafe.StringData(0 /* ERROR "cannot use 0" */) 1021 unsafe.StringData(S /* ERROR "cannot use S" */ ("foo")) 1022 unsafe /* ERROR "not used" */ .StringData(s) 1023 1024 _ = unsafe.StringData(s) 1025 _ = unsafe.StringData("foo") 1026} 1027 1028// self-testing only 1029func assert1() { 1030 var x int 1031 assert() /* ERROR "not enough arguments" */ 1032 assert(1, 2) /* ERROR "too many arguments" */ 1033 assert("foo" /* ERROR "boolean constant" */ ) 1034 assert(x /* ERROR "boolean constant" */) 1035 assert(true) 1036 assert /* ERROR "failed" */ (false) 1037 _ = assert(true) 1038 1039 var s []byte 1040 assert(s... /* ERROR "invalid use of ..." */ ) 1041} 1042 1043func assert2() { 1044 f1 := func() (x bool) { return } 1045 f2 := func() (x bool) { return } 1046 assert(f0 /* ERROR "used as value" */ ()) 1047 assert(f1 /* ERROR "boolean constant" */ ()) 1048 assert(f2 /* ERROR "boolean constant" */ ()) 1049} 1050 1051// self-testing only 1052func trace1() { 1053 // Uncomment the code below to test trace - will produce console output 1054 // _ = trace /* ERROR "no value" */ () 1055 // _ = trace(1) 1056 // _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar") 1057 1058 var s []byte 1059 trace(s... /* ERROR "invalid use of ..." */ ) 1060} 1061 1062func trace2() { 1063 f1 := func() (x int) { return } 1064 f2 := func() (x int, y string) { return } 1065 f3 := func() (x int, y string, z []int) { return } 1066 _ = f1 1067 _ = f2 1068 _ = f3 1069 // Uncomment the code below to test trace - will produce console output 1070 // trace(f0()) 1071 // trace(f1()) 1072 // trace(f2()) 1073 // trace(f3()) 1074 // trace(f0(), 1) 1075 // trace(f1(), 1, 2) 1076 // trace(f2(), 1, 2, 3) 1077 // trace(f3(), 1, 2, 3, 4) 1078} 1079