third_party/gofrontend/libgo/go/go/types/testdata/builtins.src - llvm-project/llgo - Git at Google

 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // builtin calls

 package builtins

 import "unsafe"

 func _append() {
 	var x int
 	var s []byte
 	_0 := append /* ERROR "argument" */ ()
 	_1 := append("foo" /* ERROR "not a typed slice" */)
 	_2 := append(nil /* ERROR "not a typed slice" */, s)
 	_3 := append(x /* ERROR "not a typed slice" */, s)
 	_4 := append(s)
 	append /* ERROR "not used" */ (s)
 }

 func _cap() {
 	var a [10]bool
 	var p *[20]int
 	var s []int
 	var c chan string
 	_0 := cap /* ERROR "argument" */ ()
 	_1 := cap /* ERROR "argument" */ (1, 2)
 	_2 := cap(42 /* ERROR "invalid" */)
 	const _3 = cap(a)
 	assert(_3 == 10)
 	const _4 = cap(p)
 	assert(_4 == 20)
 	_5 := cap(c)
 	cap /* ERROR "not used" */ (c)
 }

 func _close() {
 	var c chan int
 	var r <-chan int
 	close /* ERROR "argument" */ ()
 	close /* ERROR "argument" */ (1, 2)
 	close(42 /* ERROR "not a channel" */)
 	close(r /* ERROR "receive-only channel" */)
 	close(c)
 }

 func _complex() {
 	var i32 int32
 	var f32 float32
 	var f64 float64
 	var c64 complex64
 	_ = complex /* ERROR "argument" */ ()
 	_ = complex /* ERROR "argument" */ (1)
 	_ = complex(true /* ERROR "invalid argument" */ , 0)
 	_ = complex(i32 /* ERROR "invalid argument" */ , 0)
 	_ = complex("foo" /* ERROR "invalid argument" */ , 0)
 	_ = complex(c64 /* ERROR "invalid argument" */ , 0)
 	_ = complex(0, true /* ERROR "invalid argument" */ )
 	_ = complex(0, i32 /* ERROR "invalid argument" */ )
 	_ = complex(0, "foo" /* ERROR "invalid argument" */ )
 	_ = complex(0, c64 /* ERROR "invalid argument" */ )
 	_ = complex(f32, f32)
 	_ = complex(f32, 1)
 	_ = complex(f32, 1.0)
 	_ = complex(f32, 'a')
 	_ = complex(f64, f64)
 	_ = complex(f64, 1)
 	_ = complex(f64, 1.0)
 	_ = complex(f64, 'a')
 	_ = complex(f32 /* ERROR "mismatched types" */, f64)
 	_ = complex(f64 /* ERROR "mismatched types" */, f32)
 	_ = complex(1, 1)
 	_ = complex(1, 1.1)
 	_ = complex(1, 'a')
 	complex /* ERROR "not used" */ (1, 2)
 }

 func _copy() {
 	copy /* ERROR "not enough arguments" */ ()
 	copy /* ERROR "not enough arguments" */ ("foo")
 	copy([ /* ERROR "copy expects slice arguments" */ ...]int{}, []int{})
 	copy([ /* ERROR "copy expects slice arguments" */ ]int{}, [...]int{})
 	copy([ /* ERROR "different element types" */ ]int8{}, "foo")

 	// spec examples
 	var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
 	var s = make([]int, 6)
 	var b = make([]byte, 5)
 	n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
 	n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
 	n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")
 }

 func _delete() {
 	var m map[string]int
 	var s string
 	delete /* ERROR "argument" */ ()
 	delete /* ERROR "argument" */ (1)
 	delete /* ERROR "argument" */ (1, 2, 3)
 	delete(m, 0 /* ERROR "not assignable" */)
 	delete(m, s)
 }

 func _imag() {
 	var f32 float32
 	var f64 float64
 	var c64 complex64
 	var c128 complex128
 	_ = imag /* ERROR "argument" */ ()
 	_ = imag /* ERROR "argument" */ (1, 2)
 	_ = imag(10 /* ERROR "must be a complex number" */)
 	_ = imag(2.7182818 /* ERROR "must be a complex number" */)
 	_ = imag("foo" /* ERROR "must be a complex number" */)
 	const _5 = imag(1 + 2i)
 	assert(_5 == 2)
 	f32 = _5
 	f64 = _5
 	const _6 = imag(0i)
 	assert(_6 == 0)
 	f32 = imag(c64)
 	f64 = imag(c128)
 	f32 = imag /* ERROR "cannot assign" */ (c128)
 	f64 = imag /* ERROR "cannot assign" */ (c64)
 	imag /* ERROR "not used" */ (c64)
 }

 func _len() {
 	const c = "foobar"
 	var a [10]bool
 	var p *[20]int
 	var s []int
 	var m map[string]complex128
 	_ = len /* ERROR "argument" */ ()
 	_ = len /* ERROR "argument" */ (1, 2)
 	_ = len(42 /* ERROR "invalid" */)
 	const _3 = len(c)
 	assert(_3 == 6)
 	const _4 = len(a)
 	assert(_4 == 10)
 	const _5 = len(p)
 	assert(_5 == 20)
 	_ = len(m)
 	len /* ERROR "not used" */ (c)

 	// esoteric case
 	var t string
 	var hash map[interface{}][]*[10]int
 	const n = len /* ERROR "not constant" */ (hash[recover()][len(t)])
 	assert /* ERROR "failed" */ (n == 10)
 	var ch <-chan int
 	const nn = len /* ERROR "not constant" */ (hash[<-ch][len(t)])
 	_ = nn // TODO(gri) remove this once unused constants get type-checked
 }

 func _make() {
 	n := 0

 	_ = make /* ERROR "argument" */ ()
 	_ = make(1 /* ERROR "not a type" */)
 	_ = make(int /* ERROR "cannot make" */)

 	// slices
 	_ = make/* ERROR "arguments" */ ([]int)
 	_ = make/* ERROR "arguments" */ ([]int, 2, 3, 4)
 	_ = make([]int, int /* ERROR "not an expression" */)
 	_ = make([]int, 10, float32 /* ERROR "not an expression" */)
 	_ = make([]int, "foo" /* ERROR "must be an integer" */)
 	_ = make([]int, 10, 2.3 /* ERROR "must be an integer" */)
 	_ = make([]int, 5, 10.0)
 	_ = make([]int, 0i)
 	_ = make([]int, - /* ERROR "must not be negative" */ 1, 10)
 	_ = make([]int, 0, - /* ERROR "must not be negative" */ 1)
 	_ = make([]int, - /* ERROR "must not be negative" */ 1, - /* ERROR "must not be negative" */ 1)
 	_ = make([]int, 1<<100, 1<<100)  // run-time panic
 	_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100 + 1, 1<<100)
 	_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100, 12345)

 	// maps
 	_ = make /* ERROR "arguments" */ (map[int]string, 10, 20)
 	_ = make(map[int]float32, int /* ERROR "not an expression" */)
 	_ = make(map[int]float32, "foo" /* ERROR "must be an integer" */)
 	_ = make(map[int]float32, 10)
 	_ = make(map[int]float32, n)
 	_ = make(map[int]float32, int64(n))

 	// channels
 	_ = make /* ERROR "arguments" */ (chan int, 10, 20)
 	_ = make(chan int, int /* ERROR "not an expression" */)
 	_ = make(chan<- int, "foo" /* ERROR "must be an integer" */)
 	_ = make(<-chan float64, 10)
 	_ = make(chan chan int, n)
 	_ = make(chan string, int64(n))

 	make /* ERROR "not used" */ ([]int, 10)
 }

 func _new() {
 	_ = new /* ERROR "argument" */ ()
 	_ = new /* ERROR "argument" */ (1, 2)
 	_ = new("foo" /* ERROR "not a type" */)
 	p := new(float64)
 	_ = new(struct{ x, y int })
 	q := new(*float64)
 	_ = *p == **q
 	new /* ERROR "not used" */ (int)
 }

 func _real() {
 	var f32 float32
 	var f64 float64
 	var c64 complex64
 	var c128 complex128
 	_ = real /* ERROR "argument" */ ()
 	_ = real /* ERROR "argument" */ (1, 2)
 	_ = real(10 /* ERROR "must be a complex number" */)
 	_ = real(2.7182818 /* ERROR "must be a complex number" */)
 	_ = real("foo" /* ERROR "must be a complex number" */)
 	const _5 = real(1 + 2i)
 	assert(_5 == 1)
 	f32 = _5
 	f64 = _5
 	const _6 = real(0i)
 	assert(_6 == 0)
 	f32 = real(c64)
 	f64 = real(c128)
 	f32 = real /* ERROR "cannot assign" */ (c128)
 	f64 = real /* ERROR "cannot assign" */ (c64)
 	real /* ERROR "not used" */ (c64)
 }

 func _recover() {
 	_ = recover()
 	_ = recover /* ERROR "argument" */ (10)
 	recover()
 }

 func _Alignof() {
 	var x int
 	_ = unsafe /* ERROR "argument" */ .Alignof()
 	_ = unsafe /* ERROR "argument" */ .Alignof(1, 2)
 	_ = unsafe.Alignof(int /* ERROR "not an expression" */)
 	_ = unsafe.Alignof(42)
 	_ = unsafe.Alignof(new(struct{}))
 	unsafe /* ERROR "not used" */ .Alignof(x)
 }

 func _Offsetof() {
 	var x struct{ f int }
 	_ = unsafe /* ERROR "argument" */ .Offsetof()
 	_ = unsafe /* ERROR "argument" */ .Offsetof(1, 2)
 	_ = unsafe.Offsetof(int /* ERROR "not an expression" */)
 	_ = unsafe.Offsetof(x /* ERROR "not a selector" */)
 	_ = unsafe.Offsetof(x.f)
 	_ = unsafe.Offsetof((x.f))
 	_ = unsafe.Offsetof((((((((x))).f)))))
 	unsafe /* ERROR "not used" */ .Offsetof(x.f)
 }

 func _Sizeof() {
 	var x int
 	_ = unsafe /* ERROR "argument" */ .Sizeof()
 	_ = unsafe /* ERROR "argument" */ .Sizeof(1, 2)
 	_ = unsafe.Sizeof(int /* ERROR "not an expression" */)
 	_ = unsafe.Sizeof(42)
 	_ = unsafe.Sizeof(new(complex128))
 	unsafe /* ERROR "not used" */ .Sizeof(x)

 	// basic types have size guarantees
 	assert(unsafe.Sizeof(byte(0)) == 1)
 	assert(unsafe.Sizeof(uint8(0)) == 1)
 	assert(unsafe.Sizeof(int8(0)) == 1)
 	assert(unsafe.Sizeof(uint16(0)) == 2)
 	assert(unsafe.Sizeof(int16(0)) == 2)
 	assert(unsafe.Sizeof(uint32(0)) == 4)
 	assert(unsafe.Sizeof(int32(0)) == 4)
 	assert(unsafe.Sizeof(float32(0)) == 4)
 	assert(unsafe.Sizeof(uint64(0)) == 8)
 	assert(unsafe.Sizeof(int64(0)) == 8)
 	assert(unsafe.Sizeof(float64(0)) == 8)
 	assert(unsafe.Sizeof(complex64(0)) == 8)
 	assert(unsafe.Sizeof(complex128(0)) == 16)
 }

 // self-testing only
 func _assert() {
 	var x int
 	assert /* ERROR "argument" */ ()
 	assert /* ERROR "argument" */ (1, 2)
 	assert("foo" /* ERROR "boolean constant" */ )
 	assert(x /* ERROR "boolean constant" */)
 	assert(true)
 	assert /* ERROR "failed" */ (false)
 }

 // self-testing only
 func _trace() {
 	// Uncomment the code below to test trace - will produce console output
 	// _ = trace /* ERROR "no value" */ ()
 	// _ = trace(1)
 	// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
 }
	// Copyright 2012 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// builtin calls

	package builtins

	import "unsafe"

	func _append() {
	var x int
	var s []byte
	_0 := append /* ERROR "argument" */ ()
	_1 := append("foo" /* ERROR "not a typed slice" */)
	_2 := append(nil /* ERROR "not a typed slice" */, s)
	_3 := append(x /* ERROR "not a typed slice" */, s)
	_4 := append(s)
	append /* ERROR "not used" */ (s)
	}

	func _cap() {
	var a [10]bool
	var p *[20]int
	var s []int
	var c chan string
	_0 := cap /* ERROR "argument" */ ()
	_1 := cap /* ERROR "argument" */ (1, 2)
	_2 := cap(42 /* ERROR "invalid" */)
	const _3 = cap(a)
	assert(_3 == 10)
	const _4 = cap(p)
	assert(_4 == 20)
	_5 := cap(c)
	cap /* ERROR "not used" */ (c)
	}

	func _close() {
	var c chan int
	var r <-chan int
	close /* ERROR "argument" */ ()
	close /* ERROR "argument" */ (1, 2)
	close(42 /* ERROR "not a channel" */)
	close(r /* ERROR "receive-only channel" */)
	close(c)
	}

	func _complex() {
	var i32 int32
	var f32 float32
	var f64 float64
	var c64 complex64
	_ = complex /* ERROR "argument" */ ()
	_ = complex /* ERROR "argument" */ (1)
	_ = complex(true /* ERROR "invalid argument" */ , 0)
	_ = complex(i32 /* ERROR "invalid argument" */ , 0)
	_ = complex("foo" /* ERROR "invalid argument" */ , 0)
	_ = complex(c64 /* ERROR "invalid argument" */ , 0)
	_ = complex(0, true /* ERROR "invalid argument" */ )
	_ = complex(0, i32 /* ERROR "invalid argument" */ )
	_ = complex(0, "foo" /* ERROR "invalid argument" */ )
	_ = complex(0, c64 /* ERROR "invalid argument" */ )
	_ = complex(f32, f32)
	_ = complex(f32, 1)
	_ = complex(f32, 1.0)
	_ = complex(f32, 'a')
	_ = complex(f64, f64)
	_ = complex(f64, 1)
	_ = complex(f64, 1.0)
	_ = complex(f64, 'a')
	_ = complex(f32 /* ERROR "mismatched types" */, f64)
	_ = complex(f64 /* ERROR "mismatched types" */, f32)
	_ = complex(1, 1)
	_ = complex(1, 1.1)
	_ = complex(1, 'a')
	complex /* ERROR "not used" */ (1, 2)
	}

	func _copy() {
	copy /* ERROR "not enough arguments" */ ()
	copy /* ERROR "not enough arguments" */ ("foo")
	copy([ /* ERROR "copy expects slice arguments" */ ...]int{}, []int{})
	copy([ /* ERROR "copy expects slice arguments" */ ]int{}, [...]int{})
	copy([ /* ERROR "different element types" */ ]int8{}, "foo")

	// spec examples
	var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
	var s = make([]int, 6)
	var b = make([]byte, 5)
	n1 := copy(s, a[0:]) // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
	n2 := copy(s, s[2:]) // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
	n3 := copy(b, "Hello, World!") // n3 == 5, b == []byte("Hello")
	}

	func _delete() {
	var m map[string]int
	var s string
	delete /* ERROR "argument" */ ()
	delete /* ERROR "argument" */ (1)
	delete /* ERROR "argument" */ (1, 2, 3)
	delete(m, 0 /* ERROR "not assignable" */)
	delete(m, s)
	}

	func _imag() {
	var f32 float32
	var f64 float64
	var c64 complex64
	var c128 complex128
	_ = imag /* ERROR "argument" */ ()
	_ = imag /* ERROR "argument" */ (1, 2)
	_ = imag(10 /* ERROR "must be a complex number" */)
	_ = imag(2.7182818 /* ERROR "must be a complex number" */)
	_ = imag("foo" /* ERROR "must be a complex number" */)
	const _5 = imag(1 + 2i)
	assert(_5 == 2)
	f32 = _5
	f64 = _5
	const _6 = imag(0i)
	assert(_6 == 0)
	f32 = imag(c64)
	f64 = imag(c128)
	f32 = imag /* ERROR "cannot assign" */ (c128)
	f64 = imag /* ERROR "cannot assign" */ (c64)
	imag /* ERROR "not used" */ (c64)
	}

	func _len() {
	const c = "foobar"
	var a [10]bool
	var p *[20]int
	var s []int
	var m map[string]complex128
	_ = len /* ERROR "argument" */ ()
	_ = len /* ERROR "argument" */ (1, 2)
	_ = len(42 /* ERROR "invalid" */)
	const _3 = len(c)
	assert(_3 == 6)
	const _4 = len(a)
	assert(_4 == 10)
	const _5 = len(p)
	assert(_5 == 20)
	_ = len(m)
	len /* ERROR "not used" */ (c)

	// esoteric case
	var t string
	var hash map[interface{}][]*[10]int
	const n = len /* ERROR "not constant" */ (hash[recover()][len(t)])
	assert /* ERROR "failed" */ (n == 10)
	var ch <-chan int
	const nn = len /* ERROR "not constant" */ (hash[<-ch][len(t)])
	_ = nn // TODO(gri) remove this once unused constants get type-checked
	}

	func _make() {
	n := 0

	_ = make /* ERROR "argument" */ ()
	_ = make(1 /* ERROR "not a type" */)
	_ = make(int /* ERROR "cannot make" */)

	// slices
	_ = make/* ERROR "arguments" */ ([]int)
	_ = make/* ERROR "arguments" */ ([]int, 2, 3, 4)
	_ = make([]int, int /* ERROR "not an expression" */)
	_ = make([]int, 10, float32 /* ERROR "not an expression" */)
	_ = make([]int, "foo" /* ERROR "must be an integer" */)
	_ = make([]int, 10, 2.3 /* ERROR "must be an integer" */)
	_ = make([]int, 5, 10.0)
	_ = make([]int, 0i)
	_ = make([]int, - /* ERROR "must not be negative" */ 1, 10)
	_ = make([]int, 0, - /* ERROR "must not be negative" */ 1)
	_ = make([]int, - /* ERROR "must not be negative" / 1, - / ERROR "must not be negative" */ 1)
	_ = make([]int, 1<<100, 1<<100) // run-time panic
	_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100 + 1, 1<<100)
	_ = make([]int, 1 /* ERROR "length and capacity swapped" */ <<100, 12345)

	// maps
	_ = make /* ERROR "arguments" */ (map[int]string, 10, 20)
	_ = make(map[int]float32, int /* ERROR "not an expression" */)
	_ = make(map[int]float32, "foo" /* ERROR "must be an integer" */)
	_ = make(map[int]float32, 10)
	_ = make(map[int]float32, n)
	_ = make(map[int]float32, int64(n))

	// channels
	_ = make /* ERROR "arguments" */ (chan int, 10, 20)
	_ = make(chan int, int /* ERROR "not an expression" */)
	_ = make(chan<- int, "foo" /* ERROR "must be an integer" */)
	_ = make(<-chan float64, 10)
	_ = make(chan chan int, n)
	_ = make(chan string, int64(n))

	make /* ERROR "not used" */ ([]int, 10)
	}

	func _new() {
	_ = new /* ERROR "argument" */ ()
	_ = new /* ERROR "argument" */ (1, 2)
	_ = new("foo" /* ERROR "not a type" */)
	p := new(float64)
	_ = new(struct{ x, y int })
	q := new(*float64)
	_ = p == *q
	new /* ERROR "not used" */ (int)
	}

	func _real() {
	var f32 float32
	var f64 float64
	var c64 complex64
	var c128 complex128
	_ = real /* ERROR "argument" */ ()
	_ = real /* ERROR "argument" */ (1, 2)
	_ = real(10 /* ERROR "must be a complex number" */)
	_ = real(2.7182818 /* ERROR "must be a complex number" */)
	_ = real("foo" /* ERROR "must be a complex number" */)
	const _5 = real(1 + 2i)
	assert(_5 == 1)
	f32 = _5
	f64 = _5
	const _6 = real(0i)
	assert(_6 == 0)
	f32 = real(c64)
	f64 = real(c128)
	f32 = real /* ERROR "cannot assign" */ (c128)
	f64 = real /* ERROR "cannot assign" */ (c64)
	real /* ERROR "not used" */ (c64)
	}

	func _recover() {
	_ = recover()
	_ = recover /* ERROR "argument" */ (10)
	recover()
	}

	func _Alignof() {
	var x int
	_ = unsafe /* ERROR "argument" */ .Alignof()
	_ = unsafe /* ERROR "argument" */ .Alignof(1, 2)
	_ = unsafe.Alignof(int /* ERROR "not an expression" */)
	_ = unsafe.Alignof(42)
	_ = unsafe.Alignof(new(struct{}))
	unsafe /* ERROR "not used" */ .Alignof(x)
	}

	func _Offsetof() {
	var x struct{ f int }
	_ = unsafe /* ERROR "argument" */ .Offsetof()
	_ = unsafe /* ERROR "argument" */ .Offsetof(1, 2)
	_ = unsafe.Offsetof(int /* ERROR "not an expression" */)
	_ = unsafe.Offsetof(x /* ERROR "not a selector" */)
	_ = unsafe.Offsetof(x.f)
	_ = unsafe.Offsetof((x.f))
	_ = unsafe.Offsetof((((((((x))).f)))))
	unsafe /* ERROR "not used" */ .Offsetof(x.f)
	}

	func _Sizeof() {
	var x int
	_ = unsafe /* ERROR "argument" */ .Sizeof()
	_ = unsafe /* ERROR "argument" */ .Sizeof(1, 2)
	_ = unsafe.Sizeof(int /* ERROR "not an expression" */)
	_ = unsafe.Sizeof(42)
	_ = unsafe.Sizeof(new(complex128))
	unsafe /* ERROR "not used" */ .Sizeof(x)

	// basic types have size guarantees
	assert(unsafe.Sizeof(byte(0)) == 1)
	assert(unsafe.Sizeof(uint8(0)) == 1)
	assert(unsafe.Sizeof(int8(0)) == 1)
	assert(unsafe.Sizeof(uint16(0)) == 2)
	assert(unsafe.Sizeof(int16(0)) == 2)
	assert(unsafe.Sizeof(uint32(0)) == 4)
	assert(unsafe.Sizeof(int32(0)) == 4)
	assert(unsafe.Sizeof(float32(0)) == 4)
	assert(unsafe.Sizeof(uint64(0)) == 8)
	assert(unsafe.Sizeof(int64(0)) == 8)
	assert(unsafe.Sizeof(float64(0)) == 8)
	assert(unsafe.Sizeof(complex64(0)) == 8)
	assert(unsafe.Sizeof(complex128(0)) == 16)
	}

	// self-testing only
	func _assert() {
	var x int
	assert /* ERROR "argument" */ ()
	assert /* ERROR "argument" */ (1, 2)
	assert("foo" /* ERROR "boolean constant" */ )
	assert(x /* ERROR "boolean constant" */)
	assert(true)
	assert /* ERROR "failed" */ (false)
	}

	// self-testing only
	func _trace() {
	// Uncomment the code below to test trace - will produce console output
	// _ = trace /* ERROR "no value" */ ()
	// _ = trace(1)
	// _ = trace(true, 1.2, '\'', "foo", 42i, "foo" <= "bar")
	}