...
Run Format

Text file src/go/types/testdata/builtins.src

Documentation: go/types/testdata

     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	
     7	package builtins
     8	
     9	import "unsafe"
    10	
    11	func f0() {}
    12	
    13	func append1() {
    14		var b byte
    15		var x int
    16		var s []byte
    17		_ = append() // ERROR not enough arguments
    18		_ = append("foo" /* ERROR not a slice */ )
    19		_ = append(nil /* ERROR not a slice */ , s)
    20		_ = append(x /* ERROR not 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 can only use ... with matching parameter */ )
    29		_ = append(s, b, s... /* ERROR can only use ... with matching parameter */ )
    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, s... /* ERROR can only use ... with matching parameter */ )
    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" /* ERROR cannot convert */ )
    39		_ = append(s, "foo"...)
    40		_ = append(S(s), "foo" /* ERROR cannot convert */ )
    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
    53	func 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	
    69	func 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 not a slice */ ()) // TODO(gri) better error message
    81	}
    82	
    83	func 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 \.\.\. */ )
   104	}
   105	
   106	func cap2() {
   107		f1a := func() (a [10]int) { return }
   108		f1s := func() (s []int) { return }
   109		f2 := func() (s []int, x int) { return }
   110		_ = cap(f0 /* ERROR used as value */ ())
   111		_ = cap(f1a())
   112		_ = cap(f1s())
   113		_ = cap(f2()) // ERROR too many arguments
   114	}
   115	
   116	// test cases for issue 7387
   117	func cap3() {
   118		var f = func() int { return 0 }
   119		var x = f()
   120		const (
   121			_ = cap([4]int{})
   122			_ = cap([4]int{x})
   123			_ = cap /* ERROR not constant */ ([4]int{f()})
   124			_ = cap /* ERROR not constant */ ([4]int{cap([]int{})})
   125			_ = cap([4]int{cap([4]int{})})
   126		)
   127		var y float64
   128		var z complex128
   129		const (
   130			_ = cap([4]float64{})
   131			_ = cap([4]float64{y})
   132			_ = cap([4]float64{real(2i)})
   133			_ = cap /* ERROR not constant */ ([4]float64{real(z)})
   134		)
   135		var ch chan [10]int
   136		const (
   137			_ = cap /* ERROR not constant */ (<-ch)
   138			_ = cap /* ERROR not constant */ ([4]int{(<-ch)[0]})
   139		)
   140	}
   141	
   142	func close1() {
   143		var c chan int
   144		var r <-chan int
   145		close() // ERROR not enough arguments
   146		close(1, 2) // ERROR too many arguments
   147		close(42 /* ERROR not a channel */)
   148		close(r /* ERROR receive-only channel */)
   149		close(c)
   150		_ = close /* ERROR used as value */ (c)
   151	
   152		var s []chan int
   153		close(s... /* ERROR invalid use of \.\.\. */ )
   154	}
   155	
   156	func close2() {
   157		f1 := func() (ch chan int) { return }
   158		f2 := func() (ch chan int, x int) { return }
   159		close(f0 /* ERROR used as value */ ())
   160		close(f1())
   161		close(f2()) // ERROR too many arguments
   162	}
   163	
   164	func complex1() {
   165		var i32 int32
   166		var f32 float32
   167		var f64 float64
   168		var c64 complex64
   169		var c128 complex128
   170		_ = complex() // ERROR not enough arguments
   171		_ = complex(1) // ERROR not enough arguments
   172		_ = complex(true /* ERROR mismatched types */ , 0)
   173		_ = complex(i32 /* ERROR expected floating-point */ , 0)
   174		_ = complex("foo" /* ERROR mismatched types */ , 0)
   175		_ = complex(c64 /* ERROR expected floating-point */ , 0)
   176		_ = complex(0 /* ERROR mismatched types */ , true)
   177		_ = complex(0 /* ERROR expected floating-point */ , i32)
   178		_ = complex(0 /* ERROR mismatched types */ , "foo")
   179		_ = complex(0 /* ERROR expected floating-point */ , c64)
   180		_ = complex(f32, f32)
   181		_ = complex(f32, 1)
   182		_ = complex(f32, 1.0)
   183		_ = complex(f32, 'a')
   184		_ = complex(f64, f64)
   185		_ = complex(f64, 1)
   186		_ = complex(f64, 1.0)
   187		_ = complex(f64, 'a')
   188		_ = complex(f32 /* ERROR mismatched types */ , f64)
   189		_ = complex(f64 /* ERROR mismatched types */ , f32)
   190		_ = complex(1, 1)
   191		_ = complex(1, 1.1)
   192		_ = complex(1, 'a')
   193		complex /* ERROR not used */ (1, 2)
   194	
   195		var _ complex64 = complex(f32, f32)
   196		var _ complex64 = complex /* ERROR cannot use .* in variable declaration */ (f64, f64)
   197	
   198		var _ complex128 = complex /* ERROR cannot use .* in variable declaration */ (f32, f32)
   199		var _ complex128 = complex(f64, f64)
   200	
   201		// untyped constants
   202		const _ int = complex(1, 0)
   203		const _ float32 = complex(1, 0)
   204		const _ complex64 = complex(1, 0)
   205		const _ complex128 = complex(1, 0)
   206		const _ = complex(0i, 0i)
   207		const _ = complex(0i, 0)
   208		const _ int = 1.0 + complex(1, 0i)
   209	
   210		const _ int = complex /* ERROR int */ (1.1, 0)
   211		const _ float32 = complex /* ERROR float32 */ (1, 2)
   212	
   213		// untyped values
   214		var s uint
   215		_ = complex(1 /* ERROR integer */ <<s, 0)
   216		const _ = complex /* ERROR not constant */ (1 /* ERROR integer */ <<s, 0)
   217		var _ int = complex /* ERROR cannot use .* in variable declaration */ (1 /* ERROR integer */ <<s, 0)
   218	
   219		// floating-point argument types must be identical
   220		type F32 float32
   221		type F64 float64
   222		var x32 F32
   223		var x64 F64
   224		c64 = complex(x32, x32)
   225		_ = complex(x32 /* ERROR mismatched types */ , f32)
   226		_ = complex(f32 /* ERROR mismatched types */ , x32)
   227		c128 = complex(x64, x64)
   228		_ = c128
   229		_ = complex(x64 /* ERROR mismatched types */ , f64)
   230		_ = complex(f64 /* ERROR mismatched types */ , x64)
   231	
   232		var t []float32
   233		_ = complex(t... /* ERROR invalid use of \.\.\. */ )
   234	}
   235	
   236	func complex2() {
   237		f1 := func() (x float32) { return }
   238		f2 := func() (x, y float32) { return }
   239		f3 := func() (x, y, z float32) { return }
   240		_ = complex(f0 /* ERROR used as value */ ())
   241		_ = complex(f1()) // ERROR not enough arguments
   242		_ = complex(f2())
   243		_ = complex(f3()) // ERROR too many arguments
   244	}
   245	
   246	func copy1() {
   247		copy() // ERROR not enough arguments
   248		copy("foo") // ERROR not enough arguments
   249		copy([ /* ERROR copy expects slice arguments */ ...]int{}, []int{})
   250		copy([ /* ERROR copy expects slice arguments */ ]int{}, [...]int{})
   251		copy([ /* ERROR different element types */ ]int8{}, "foo")
   252	
   253		// spec examples
   254		var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
   255		var s = make([]int, 6)
   256		var b = make([]byte, 5)
   257		n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
   258		n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
   259		n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")
   260		_, _, _ = n1, n2, n3
   261	
   262		var t [][]int
   263		copy(t, t)
   264		copy(t /* ERROR copy expects slice arguments */ , nil)
   265		copy(nil /* ERROR copy expects slice arguments */ , t)
   266		copy(nil /* ERROR copy expects slice arguments */ , nil)
   267		copy(t... /* ERROR invalid use of \.\.\. */ )
   268	}
   269	
   270	func copy2() {
   271		f1 := func() (a []int) { return }
   272		f2 := func() (a, b []int) { return }
   273		f3 := func() (a, b, c []int) { return }
   274		copy(f0 /* ERROR used as value */ ())
   275		copy(f1()) // ERROR not enough arguments
   276		copy(f2())
   277		copy(f3()) // ERROR too many arguments
   278	}
   279	
   280	func delete1() {
   281		var m map[string]int
   282		var s string
   283		delete() // ERROR not enough arguments
   284		delete(1) // ERROR not enough arguments
   285		delete(1, 2, 3) // ERROR too many arguments
   286		delete(m, 0 /* ERROR not assignable */)
   287		delete(m, s)
   288		_ = delete /* ERROR used as value */ (m, s)
   289	
   290		var t []map[string]string
   291		delete(t... /* ERROR invalid use of \.\.\. */ )
   292	}
   293	
   294	func delete2() {
   295		f1 := func() (m map[string]int) { return }
   296		f2 := func() (m map[string]int, k string) { return }
   297		f3 := func() (m map[string]int, k string, x float32) { return }
   298		delete(f0 /* ERROR used as value */ ())
   299		delete(f1()) // ERROR not enough arguments
   300		delete(f2())
   301		delete(f3()) // ERROR too many arguments
   302	}
   303	
   304	func imag1() {
   305		var f32 float32
   306		var f64 float64
   307		var c64 complex64
   308		var c128 complex128
   309		_ = imag() // ERROR not enough arguments
   310		_ = imag(1, 2) // ERROR too many arguments
   311		_ = imag(10)
   312		_ = imag(2.7182818)
   313		_ = imag("foo" /* ERROR expected complex */)
   314		_ = imag('a')
   315		const _5 = imag(1 + 2i)
   316		assert(_5 == 2)
   317		f32 = _5
   318		f64 = _5
   319		const _6 = imag(0i)
   320		assert(_6 == 0)
   321		f32 = imag(c64)
   322		f64 = imag(c128)
   323		f32 = imag /* ERROR cannot use .* in assignment */ (c128)
   324		f64 = imag /* ERROR cannot use .* in assignment */ (c64)
   325		imag /* ERROR not used */ (c64)
   326		_, _ = f32, f64
   327	
   328		// complex type may not be predeclared
   329		type C64 complex64
   330		type C128 complex128
   331		var x64 C64
   332		var x128 C128
   333		f32 = imag(x64)
   334		f64 = imag(x128)
   335	
   336		var a []complex64
   337		_ = imag(a... /* ERROR invalid use of \.\.\. */ )
   338	
   339		// if argument is untyped, result is untyped
   340		const _ byte = imag(1.2 + 3i)
   341		const _ complex128 = imag(1.2 + 3i)
   342	
   343		// lhs constant shift operands are typed as complex128
   344		var s uint
   345		_ = imag(1 /* ERROR must be integer */ << s)
   346	}
   347	
   348	func imag2() {
   349		f1 := func() (x complex128) { return }
   350		f2 := func() (x, y complex128) { return }
   351		_ = imag(f0 /* ERROR used as value */ ())
   352		_ = imag(f1())
   353		_ = imag(f2()) // ERROR too many arguments
   354	}
   355	
   356	func len1() {
   357		const c = "foobar"
   358		var a [10]bool
   359		var p *[20]int
   360		var m map[string]complex128
   361		_ = len() // ERROR not enough arguments
   362		_ = len(1, 2) // ERROR too many arguments
   363		_ = len(42 /* ERROR invalid */)
   364		const _3 = len(c)
   365		assert(_3 == 6)
   366		const _4 = len(a)
   367		assert(_4 == 10)
   368		const _5 = len(p)
   369		assert(_5 == 20)
   370		_ = len(m)
   371		len /* ERROR not used */ (c)
   372	
   373		// esoteric case
   374		var t string
   375		var hash map[interface{}][]*[10]int
   376		const n = len /* ERROR not constant */ (hash[recover()][len(t)])
   377		assert(n == 10) // ok because n has unknown value and no error is reported
   378		var ch <-chan int
   379		const nn = len /* ERROR not constant */ (hash[<-ch][len(t)])
   380	
   381		// issue 4744
   382		type T struct{ a [10]int }
   383		const _ = len(((*T)(nil)).a)
   384	
   385		var s [][]byte
   386		_ = len(s)
   387		_ = len(s... /* ERROR invalid use of \.\.\. */ )
   388	}
   389	
   390	func len2() {
   391		f1 := func() (x []int) { return }
   392		f2 := func() (x, y []int) { return }
   393		_ = len(f0 /* ERROR used as value */ ())
   394		_ = len(f1())
   395		_ = len(f2()) // ERROR too many arguments
   396	}
   397	
   398	// test cases for issue 7387
   399	func len3() {
   400		var f = func() int { return 0 }
   401		var x = f()
   402		const (
   403			_ = len([4]int{})
   404			_ = len([4]int{x})
   405			_ = len /* ERROR not constant */ ([4]int{f()})
   406			_ = len /* ERROR not constant */ ([4]int{len([]int{})})
   407			_ = len([4]int{len([4]int{})})
   408		)
   409		var y float64
   410		var z complex128
   411		const (
   412			_ = len([4]float64{})
   413			_ = len([4]float64{y})
   414			_ = len([4]float64{real(2i)})
   415			_ = len /* ERROR not constant */ ([4]float64{real(z)})
   416		)
   417		var ch chan [10]int
   418		const (
   419			_ = len /* ERROR not constant */ (<-ch)
   420			_ = len /* ERROR not constant */ ([4]int{(<-ch)[0]})
   421		)
   422	}
   423	
   424	func make1() {
   425		var n int
   426		var m float32
   427		var s uint
   428	
   429		_ = make() // ERROR not enough arguments
   430		_ = make(1 /* ERROR not a type */)
   431		_ = make(int /* ERROR cannot make */)
   432	
   433		// slices
   434		_ = make/* ERROR arguments */ ([]int)
   435		_ = make/* ERROR arguments */ ([]int, 2, 3, 4)
   436		_ = make([]int, int /* ERROR not an expression */)
   437		_ = make([]int, 10, float32 /* ERROR not an expression */)
   438		_ = make([]int, "foo" /* ERROR cannot convert */)
   439		_ = make([]int, 10, 2.3 /* ERROR truncated */)
   440		_ = make([]int, 5, 10.0)
   441		_ = make([]int, 0i)
   442		_ = make([]int, 1.0)
   443		_ = make([]int, 1.0<<s)
   444		_ = make([]int, 1.1 /* ERROR int */ <<s)
   445		_ = make([]int, - /* ERROR must not be negative */ 1, 10)
   446		_ = make([]int, 0, - /* ERROR must not be negative */ 1)
   447		_ = make([]int, - /* ERROR must not be negative */ 1, - /* ERROR must not be negative */ 1)
   448		_ = make([]int, 1 /* ERROR overflows */ <<100, 1 /* ERROR overflows */ <<100)
   449		_ = make([]int, 10 /* ERROR length and capacity swapped */ , 9)
   450		_ = make([]int, 1 /* ERROR overflows */ <<100, 12345)
   451		_ = make([]int, m /* ERROR must be integer */ )
   452	        _ = &make /* ERROR cannot take address */ ([]int, 0)
   453	
   454		// maps
   455		_ = make /* ERROR arguments */ (map[int]string, 10, 20)
   456		_ = make(map[int]float32, int /* ERROR not an expression */)
   457		_ = make(map[int]float32, "foo" /* ERROR cannot convert */)
   458		_ = make(map[int]float32, 10)
   459		_ = make(map[int]float32, n)
   460		_ = make(map[int]float32, int64(n))
   461		_ = make(map[string]bool, 10.0)
   462		_ = make(map[string]bool, 10.0<<s)
   463	        _ = &make /* ERROR cannot take address */ (map[string]bool)
   464	
   465		// channels
   466		_ = make /* ERROR arguments */ (chan int, 10, 20)
   467		_ = make(chan int, int /* ERROR not an expression */)
   468		_ = make(chan<- int, "foo" /* ERROR cannot convert */)
   469		_ = make(chan int, - /* ERROR must not be negative */ 10)
   470		_ = make(<-chan float64, 10)
   471		_ = make(chan chan int, n)
   472		_ = make(chan string, int64(n))
   473		_ = make(chan bool, 10.0)
   474		_ = make(chan bool, 10.0<<s)
   475	        _ = &make /* ERROR cannot take address */ (chan bool)
   476	
   477		make /* ERROR not used */ ([]int, 10)
   478	
   479		var t []int
   480		_ = make([]int, t[0], t[1])
   481		_ = make([]int, t... /* ERROR invalid use of \.\.\. */ )
   482	}
   483	
   484	func make2() {
   485		f1 /* ERROR not used */ := func() (x []int) { return }
   486		_ = make(f0 /* ERROR not a type */ ())
   487		_ = make(f1 /* ERROR not a type */ ())
   488	}
   489	
   490	func new1() {
   491		_ = new() // ERROR not enough arguments
   492		_ = new(1, 2) // ERROR too many arguments
   493		_ = new("foo" /* ERROR not a type */)
   494		p := new(float64)
   495		_ = new(struct{ x, y int })
   496		q := new(*float64)
   497		_ = *p == **q
   498		new /* ERROR not used */ (int)
   499	        _ = &new /* ERROR cannot take address */ (int)
   500	
   501		_ = new(int... /* ERROR invalid use of \.\.\. */ )
   502	}
   503	
   504	func new2() {
   505		f1 /* ERROR not used */ := func() (x []int) { return }
   506		_ = new(f0 /* ERROR not a type */ ())
   507		_ = new(f1 /* ERROR not a type */ ())
   508	}
   509	
   510	func panic1() {
   511		panic() // ERROR not enough arguments
   512		panic(1, 2) // ERROR too many arguments
   513		panic(0)
   514		panic("foo")
   515		panic(false)
   516		panic(1<<10)
   517		panic(1 /* ERROR overflows */ <<1000)
   518		_ = panic /* ERROR used as value */ (0)
   519	
   520		var s []byte
   521		panic(s)
   522		panic(s... /* ERROR invalid use of \.\.\. */ )
   523	}
   524	
   525	func panic2() {
   526		f1 := func() (x int) { return }
   527		f2 := func() (x, y int) { return }
   528		panic(f0 /* ERROR used as value */ ())
   529		panic(f1())
   530		panic(f2()) // ERROR too many arguments
   531	}
   532	
   533	func print1() {
   534		print()
   535		print(1)
   536		print(1, 2)
   537		print("foo")
   538		print(2.718281828)
   539		print(false)
   540		print(1<<10)
   541		print(1 /* ERROR overflows */ <<1000)
   542		println(nil /* ERROR untyped nil */ )
   543	
   544		var s []int
   545		print(s... /* ERROR invalid use of \.\.\. */ )
   546		_ = print /* ERROR used as value */ ()
   547	}
   548	
   549	func print2() {
   550		f1 := func() (x int) { return }
   551		f2 := func() (x, y int) { return }
   552		f3 := func() (x int, y float32, z string) { return }
   553		print(f0 /* ERROR used as value */ ())
   554		print(f1())
   555		print(f2())
   556		print(f3())
   557	}
   558	
   559	func println1() {
   560		println()
   561		println(1)
   562		println(1, 2)
   563		println("foo")
   564		println(2.718281828)
   565		println(false)
   566		println(1<<10)
   567		println(1 /* ERROR overflows */ <<1000)
   568		println(nil /* ERROR untyped nil */ )
   569	
   570		var s []int
   571		println(s... /* ERROR invalid use of \.\.\. */ )
   572		_ = println /* ERROR used as value */ ()
   573	}
   574	
   575	func println2() {
   576		f1 := func() (x int) { return }
   577		f2 := func() (x, y int) { return }
   578		f3 := func() (x int, y float32, z string) { return }
   579		println(f0 /* ERROR used as value */ ())
   580		println(f1())
   581		println(f2())
   582		println(f3())
   583	}
   584	
   585	func real1() {
   586		var f32 float32
   587		var f64 float64
   588		var c64 complex64
   589		var c128 complex128
   590		_ = real() // ERROR not enough arguments
   591		_ = real(1, 2) // ERROR too many arguments
   592		_ = real(10)
   593		_ = real(2.7182818)
   594		_ = real("foo" /* ERROR expected complex */)
   595		const _5 = real(1 + 2i)
   596		assert(_5 == 1)
   597		f32 = _5
   598		f64 = _5
   599		const _6 = real(0i)
   600		assert(_6 == 0)
   601		f32 = real(c64)
   602		f64 = real(c128)
   603		f32 = real /* ERROR cannot use .* in assignment */ (c128)
   604		f64 = real /* ERROR cannot use .* in assignment */ (c64)
   605		real /* ERROR not used */ (c64)
   606	
   607		// complex type may not be predeclared
   608		type C64 complex64
   609		type C128 complex128
   610		var x64 C64
   611		var x128 C128
   612		f32 = imag(x64)
   613		f64 = imag(x128)
   614		_, _ = f32, f64
   615	
   616		var a []complex64
   617		_ = real(a... /* ERROR invalid use of \.\.\. */ )
   618	
   619		// if argument is untyped, result is untyped
   620		const _ byte = real(1 + 2.3i)
   621		const _ complex128 = real(1 + 2.3i)
   622	
   623		// lhs constant shift operands are typed as complex128
   624		var s uint
   625		_ = real(1 /* ERROR must be integer */ << s)
   626	}
   627	
   628	func real2() {
   629		f1 := func() (x complex128) { return }
   630		f2 := func() (x, y complex128) { return }
   631		_ = real(f0 /* ERROR used as value */ ())
   632		_ = real(f1())
   633		_ = real(f2()) // ERROR too many arguments
   634	}
   635	
   636	func recover1() {
   637		_ = recover()
   638		_ = recover(10) // ERROR too many arguments
   639		recover()
   640	
   641		var s []int
   642		recover(s... /* ERROR invalid use of \.\.\. */ )
   643	}
   644	
   645	func recover2() {
   646		f1 := func() (x int) { return }
   647		f2 := func() (x, y int) { return }
   648		_ = recover(f0 /* ERROR used as value */ ())
   649		_ = recover(f1()) // ERROR too many arguments
   650		_ = recover(f2()) // ERROR too many arguments
   651	}
   652	
   653	// assuming types.DefaultPtrSize == 8
   654	type S0 struct{      // offset
   655		a bool       //  0
   656		b rune       //  4
   657		c *int       //  8
   658		d bool       // 16
   659		e complex128 // 24
   660	}                    // 40
   661	
   662	type S1 struct{   // offset
   663		x float32 //  0
   664		y string  //  8
   665		z *S1     // 24
   666		S0        // 32
   667	}                 // 72
   668	
   669	type S2 struct{ // offset
   670		*S1     //  0
   671	}               //  8
   672	
   673	type S3 struct { // offset
   674		a int64  //  0
   675		b int32  //  8
   676	}                // 12
   677	
   678	type S4 struct { // offset
   679		S3       //  0
   680		int32    // 12
   681	}                // 16
   682	
   683	type S5 struct {   // offset
   684		a [3]int32 //  0
   685		b int32    // 12
   686	}                  // 16
   687	
   688	func (S2) m() {}
   689	
   690	func Alignof1() {
   691		var x int
   692		_ = unsafe.Alignof() // ERROR not enough arguments
   693		_ = unsafe.Alignof(1, 2) // ERROR too many arguments
   694		_ = unsafe.Alignof(int /* ERROR not an expression */)
   695		_ = unsafe.Alignof(42)
   696		_ = unsafe.Alignof(new(struct{}))
   697		_ = unsafe.Alignof(1<<10)
   698		_ = unsafe.Alignof(1 /* ERROR overflows */ <<1000)
   699		_ = unsafe.Alignof(nil /* ERROR "untyped nil */ )
   700		unsafe /* ERROR not used */ .Alignof(x)
   701	
   702		var y S0
   703		assert(unsafe.Alignof(y.a) == 1)
   704		assert(unsafe.Alignof(y.b) == 4)
   705		assert(unsafe.Alignof(y.c) == 8)
   706		assert(unsafe.Alignof(y.d) == 1)
   707		assert(unsafe.Alignof(y.e) == 8)
   708	
   709		var s []byte
   710		_ = unsafe.Alignof(s)
   711		_ = unsafe.Alignof(s... /* ERROR invalid use of \.\.\. */ )
   712	}
   713	
   714	func Alignof2() {
   715		f1 := func() (x int32) { return }
   716		f2 := func() (x, y int32) { return }
   717		_ = unsafe.Alignof(f0 /* ERROR used as value */ ())
   718		assert(unsafe.Alignof(f1()) == 4)
   719		_ = unsafe.Alignof(f2()) // ERROR too many arguments
   720	}
   721	
   722	func Offsetof1() {
   723		var x struct{ f int }
   724		_ = unsafe.Offsetof() // ERROR not enough arguments
   725		_ = unsafe.Offsetof(1, 2) // ERROR too many arguments
   726		_ = unsafe.Offsetof(int /* ERROR not a selector expression */ )
   727		_ = unsafe.Offsetof(x /* ERROR not a selector expression */ )
   728		_ = unsafe.Offsetof(nil /* ERROR not a selector expression */ )
   729		_ = unsafe.Offsetof(x.f)
   730		_ = unsafe.Offsetof((x.f))
   731		_ = unsafe.Offsetof((((((((x))).f)))))
   732		unsafe /* ERROR not used */ .Offsetof(x.f)
   733	
   734		var y0 S0
   735		assert(unsafe.Offsetof(y0.a) == 0)
   736		assert(unsafe.Offsetof(y0.b) == 4)
   737		assert(unsafe.Offsetof(y0.c) == 8)
   738		assert(unsafe.Offsetof(y0.d) == 16)
   739		assert(unsafe.Offsetof(y0.e) == 24)
   740	
   741		var y1 S1
   742		assert(unsafe.Offsetof(y1.x) == 0)
   743		assert(unsafe.Offsetof(y1.y) == 8)
   744		assert(unsafe.Offsetof(y1.z) == 24)
   745		assert(unsafe.Offsetof(y1.S0) == 32)
   746	
   747		assert(unsafe.Offsetof(y1.S0.a) == 0) // relative to S0
   748		assert(unsafe.Offsetof(y1.a) == 32)   // relative to S1
   749		assert(unsafe.Offsetof(y1.b) == 36)   // relative to S1
   750		assert(unsafe.Offsetof(y1.c) == 40)   // relative to S1
   751		assert(unsafe.Offsetof(y1.d) == 48)   // relative to S1
   752		assert(unsafe.Offsetof(y1.e) == 56)   // relative to S1
   753	
   754		var y1p *S1
   755		assert(unsafe.Offsetof(y1p.S0) == 32)
   756	
   757		type P *S1
   758		var p P = y1p
   759		assert(unsafe.Offsetof(p.S0) == 32)
   760	
   761		var y2 S2
   762		assert(unsafe.Offsetof(y2.S1) == 0)
   763		_ = unsafe.Offsetof(y2 /* ERROR embedded via a pointer */ .x)
   764		_ = unsafe.Offsetof(y2 /* ERROR method value */ .m)
   765	
   766		var s []byte
   767		_ = unsafe.Offsetof(s... /* ERROR invalid use of \.\.\. */ )
   768	}
   769	
   770	func Offsetof2() {
   771		f1 := func() (x int32) { return }
   772		f2 := func() (x, y int32) { return }
   773		_ = unsafe.Offsetof(f0 /* ERROR not a selector expression */ ())
   774		_ = unsafe.Offsetof(f1 /* ERROR not a selector expression */ ())
   775		_ = unsafe.Offsetof(f2 /* ERROR not a selector expression */ ())
   776	}
   777	
   778	func Sizeof1() {
   779		var x int
   780		_ = unsafe.Sizeof() // ERROR not enough arguments
   781		_ = unsafe.Sizeof(1, 2) // ERROR too many arguments
   782		_ = unsafe.Sizeof(int /* ERROR not an expression */)
   783		_ = unsafe.Sizeof(42)
   784		_ = unsafe.Sizeof(new(complex128))
   785		_ = unsafe.Sizeof(1<<10)
   786		_ = unsafe.Sizeof(1 /* ERROR overflows */ <<1000)
   787		_ = unsafe.Sizeof(nil /* ERROR untyped nil */ )
   788		unsafe /* ERROR not used */ .Sizeof(x)
   789	
   790		// basic types have size guarantees
   791		assert(unsafe.Sizeof(byte(0)) == 1)
   792		assert(unsafe.Sizeof(uint8(0)) == 1)
   793		assert(unsafe.Sizeof(int8(0)) == 1)
   794		assert(unsafe.Sizeof(uint16(0)) == 2)
   795		assert(unsafe.Sizeof(int16(0)) == 2)
   796		assert(unsafe.Sizeof(uint32(0)) == 4)
   797		assert(unsafe.Sizeof(int32(0)) == 4)
   798		assert(unsafe.Sizeof(float32(0)) == 4)
   799		assert(unsafe.Sizeof(uint64(0)) == 8)
   800		assert(unsafe.Sizeof(int64(0)) == 8)
   801		assert(unsafe.Sizeof(float64(0)) == 8)
   802		assert(unsafe.Sizeof(complex64(0)) == 8)
   803		assert(unsafe.Sizeof(complex128(0)) == 16)
   804	
   805		var y0 S0
   806		assert(unsafe.Sizeof(y0.a) == 1)
   807		assert(unsafe.Sizeof(y0.b) == 4)
   808		assert(unsafe.Sizeof(y0.c) == 8)
   809		assert(unsafe.Sizeof(y0.d) == 1)
   810		assert(unsafe.Sizeof(y0.e) == 16)
   811		assert(unsafe.Sizeof(y0) == 40)
   812	
   813		var y1 S1
   814		assert(unsafe.Sizeof(y1) == 72)
   815	
   816		var y2 S2
   817		assert(unsafe.Sizeof(y2) == 8)
   818	
   819		var y3 S3
   820		assert(unsafe.Sizeof(y3) == 12)
   821	
   822		var y4 S4
   823		assert(unsafe.Sizeof(y4) == 16)
   824	
   825		var y5 S5
   826		assert(unsafe.Sizeof(y5) == 16)
   827	
   828		var a3 [10]S3
   829		assert(unsafe.Sizeof(a3) == 156)
   830	
   831		// test case for issue 5670
   832		type T struct {
   833			a int32
   834			_ int32
   835			c int32
   836		}
   837		assert(unsafe.Sizeof(T{}) == 12)
   838	
   839		var s []byte
   840		_ = unsafe.Sizeof(s)
   841		_ = unsafe.Sizeof(s... /* ERROR invalid use of \.\.\. */ )
   842	}
   843	
   844	func Sizeof2() {
   845		f1 := func() (x int64) { return }
   846		f2 := func() (x, y int64) { return }
   847		_ = unsafe.Sizeof(f0 /* ERROR used as value */ ())
   848		assert(unsafe.Sizeof(f1()) == 8)
   849		_ = unsafe.Sizeof(f2()) // ERROR too many arguments
   850	}
   851	
   852	// self-testing only
   853	func assert1() {
   854		var x int
   855		assert() /* ERROR not enough arguments */
   856		assert(1, 2) /* ERROR too many arguments */
   857		assert("foo" /* ERROR boolean constant */ )
   858		assert(x /* ERROR boolean constant */)
   859		assert(true)
   860		assert /* ERROR failed */ (false)
   861		_ = assert(true)
   862	
   863		var s []byte
   864		assert(s... /* ERROR invalid use of \.\.\. */ )
   865	}
   866	
   867	func assert2() {
   868		f1 := func() (x bool) { return }
   869		f2 := func() (x bool) { return }
   870		assert(f0 /* ERROR used as value */ ())
   871		assert(f1 /* ERROR boolean constant */ ())
   872		assert(f2 /* ERROR boolean constant */ ())
   873	}
   874	
   875	// self-testing only
   876	func trace1() {
   877		// Uncomment the code below to test trace - will produce console output
   878		// _ = trace /* ERROR no value */ ()
   879		// _ = trace(1)
   880		// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
   881	
   882		var s []byte
   883		trace(s... /* ERROR invalid use of \.\.\. */ )
   884	}
   885	
   886	func trace2() {
   887		f1 := func() (x int) { return }
   888		f2 := func() (x int, y string) { return }
   889		f3 := func() (x int, y string, z []int) { return }
   890		_ = f1
   891		_ = f2
   892		_ = f3
   893		// Uncomment the code below to test trace - will produce console output
   894		// trace(f0())
   895		// trace(f1())
   896		// trace(f2())
   897		// trace(f3())
   898		// trace(f0(), 1)
   899		// trace(f1(), 1, 2)
   900		// trace(f2(), 1, 2, 3)
   901		// trace(f3(), 1, 2, 3, 4)
   902	}

View as plain text