func TestCheckBuiltinComplexSliceType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, int)`, env,
		`type int is not an expression`,
	)
}
Test Complex([]int{}, int)
package eval
import (
	"testing"
	"reflect"
)
func TestCheckBuiltinComplexXX(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex()`, env,
		`missing argument to complex - complex(<N>, <N>)`,
	)
}
func TestCheckBuiltinComplexXInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1)`, env,
		`missing argument to complex - complex(1, <N>)`,
	)
}
func TestCheckBuiltinComplexXFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1))`, env,
		`missing argument to complex - complex(float32(1), <N>)`,
	)
}
func TestCheckBuiltinComplexXString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc")`, env,
		`missing argument to complex - complex("abc", <N>)`,
	)
}
func TestCheckBuiltinComplexXNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil)`, env,
		`missing argument to complex - complex(nil, <N>)`,
	)
}
func TestCheckBuiltinComplexXFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5)`, env,
		`missing argument to complex - complex(1.5, <N>)`,
	)
}
func TestCheckBuiltinComplexXSlice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{})`, env,
		`missing argument to complex - complex(composite literal, <N>)`,
	)
}
func TestCheckBuiltinComplexXMap(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(map[int]int{})`, env,
		`missing argument to complex - complex(composite literal, <N>)`,
	)
}
func TestCheckBuiltinComplexXType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(int)`, env,
		`missing argument to complex - complex(int, <N>)`,
	)
}
func TestCheckBuiltinComplexXMakeType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(map[int]int)`, env,
		`missing argument to complex - complex(map[int]int, <N>)`,
	)
}
func TestCheckBuiltinComplexXDouble(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1, 1)`, env, complex(1, 1), reflect.TypeOf(complex(1, 1)))
}
func TestCheckBuiltinComplexXEllipsis(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{1,2}...)`, env,
		`invalid use of ... with builtin complex`,
		`missing argument to complex - complex(composite literal, <N>)`,
	)
}
func TestCheckBuiltinComplexIntX(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1)`, env,
		`missing argument to complex - complex(1, <N>)`,
	)
}
func TestCheckBuiltinComplexIntInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1, 1)`, env, complex(1, 1), reflect.TypeOf(complex(1, 1)))
}
func TestCheckBuiltinComplexIntFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1, float32(1))`, env, complex(1, float32(1)), reflect.TypeOf(complex(1, float32(1))))
}
func TestCheckBuiltinComplexIntString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, "abc")`, env,
		`invalid operation: complex(1, "abc") (mismatched types untyped number and untyped string)`,
	)
}
func TestCheckBuiltinComplexIntNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, nil)`, env,
		`invalid operation: complex(1, nil) (mismatched types untyped number and nil)`,
	)
}
func TestCheckBuiltinComplexIntFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1, 1.5)`, env, complex(1, 1.5), reflect.TypeOf(complex(1, 1.5)))
}
func TestCheckBuiltinComplexIntSlice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, []int{})`, env,
		`invalid operation: complex(1, []int literal) (mismatched types int and []int)`,
	)
}
func TestCheckBuiltinComplexIntMap(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, map[int]int{})`, env,
		`invalid operation: complex(1, map[int]int literal) (mismatched types int and map[int]int)`,
	)
}
func TestCheckBuiltinComplexIntType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, int)`, env,
		`type int is not an expression`,
	)
}
func TestCheckBuiltinComplexIntMakeType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, map[int]int)`, env,
		`type map[int]int is not an expression`,
	)
}
func TestCheckBuiltinComplexIntDouble(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, 1, 1)`, env,
		`too many arguments to complex - complex(1, <N>)`,
	)
}
func TestCheckBuiltinComplexIntEllipsis(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1, []int{1,2}...)`, env,
		`invalid use of ... with builtin complex`,
		`invalid operation: complex(1, []int literal) (mismatched types int and []int)`,
	)
}
func TestCheckBuiltinComplexFloat32X(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1))`, env,
		`missing argument to complex - complex(float32(1), <N>)`,
	)
}
func TestCheckBuiltinComplexFloat32Int(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(float32(1), 1)`, env, complex(float32(1), 1), reflect.TypeOf(complex(float32(1), 1)))
}
func TestCheckBuiltinComplexFloat32Float32(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(float32(1), float32(1))`, env, complex(float32(1), float32(1)), reflect.TypeOf(complex(float32(1), float32(1))))
}
func TestCheckBuiltinComplexFloat32String(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), "abc")`, env,
		`cannot convert "abc" to type float32`,
		`invalid operation: complex(float32(1), "abc") (mismatched types float32 and string)`,
	)
}
func TestCheckBuiltinComplexFloat32Nil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), nil)`, env,
		`cannot convert nil to type float32`,
	)
}
func TestCheckBuiltinComplexFloat32Float(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(float32(1), 1.5)`, env, complex(float32(1), 1.5), reflect.TypeOf(complex(float32(1), 1.5)))
}
func TestCheckBuiltinComplexFloat32Slice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), []int{})`, env,
		`invalid operation: complex(float32(1), []int literal) (mismatched types float32 and []int)`,
	)
}
func TestCheckBuiltinComplexFloat32Map(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), map[int]int{})`, env,
		`invalid operation: complex(float32(1), map[int]int literal) (mismatched types float32 and map[int]int)`,
	)
}
func TestCheckBuiltinComplexFloat32Type(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), int)`, env,
		`type int is not an expression`,
	)
}
func TestCheckBuiltinComplexFloat32MakeType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), map[int]int)`, env,
		`type map[int]int is not an expression`,
	)
}
func TestCheckBuiltinComplexFloat32Double(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), 1, 1)`, env,
		`too many arguments to complex - complex(float32(1), <N>)`,
	)
}
func TestCheckBuiltinComplexFloat32Ellipsis(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(float32(1), []int{1,2}...)`, env,
		`invalid use of ... with builtin complex`,
		`invalid operation: complex(float32(1), []int literal) (mismatched types float32 and []int)`,
	)
}
func TestCheckBuiltinComplexStringX(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc")`, env,
		`missing argument to complex - complex("abc", <N>)`,
	)
}
func TestCheckBuiltinComplexStringInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", 1)`, env,
		`invalid operation: complex("abc", 1) (mismatched types untyped string and untyped number)`,
	)
}
func TestCheckBuiltinComplexStringFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", float32(1))`, env,
		`cannot convert "abc" to type float32`,
		`invalid operation: complex("abc", float32(1)) (mismatched types string and float32)`,
	)
}
func TestCheckBuiltinComplexStringString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", "abc")`, env,
		`invalid operation: complex("abc", "abc") (arguments have type untyped string, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexStringNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", nil)`, env,
		`invalid operation: complex("abc", nil) (mismatched types untyped string and nil)`,
	)
}
func TestCheckBuiltinComplexStringFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", 1.5)`, env,
		`invalid operation: complex("abc", 1.5) (mismatched types untyped string and untyped number)`,
	)
}
func TestCheckBuiltinComplexStringSlice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", []int{})`, env,
		`invalid operation: complex("abc", []int literal) (mismatched types string and []int)`,
	)
}
func TestCheckBuiltinComplexStringMap(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", map[int]int{})`, env,
		`invalid operation: complex("abc", map[int]int literal) (mismatched types string and map[int]int)`,
	)
}
func TestCheckBuiltinComplexStringType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", int)`, env,
		`type int is not an expression`,
	)
}
func TestCheckBuiltinComplexStringMakeType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", map[int]int)`, env,
		`type map[int]int is not an expression`,
	)
}
func TestCheckBuiltinComplexStringDouble(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", 1, 1)`, env,
		`too many arguments to complex - complex("abc", <N>)`,
	)
}
func TestCheckBuiltinComplexStringEllipsis(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex("abc", []int{1,2}...)`, env,
		`invalid use of ... with builtin complex`,
		`invalid operation: complex("abc", []int literal) (mismatched types string and []int)`,
	)
}
func TestCheckBuiltinComplexNilX(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil)`, env,
		`missing argument to complex - complex(nil, <N>)`,
	)
}
func TestCheckBuiltinComplexNilInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, 1)`, env,
		`invalid operation: complex(nil, 1) (mismatched types nil and untyped number)`,
	)
}
func TestCheckBuiltinComplexNilFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, float32(1))`, env,
		`cannot convert nil to type float32`,
	)
}
func TestCheckBuiltinComplexNilString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, "abc")`, env,
		`invalid operation: complex(nil, "abc") (mismatched types nil and untyped string)`,
	)
}
func TestCheckBuiltinComplexNilNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, nil)`, env,
		`invalid operation: complex(nil, nil) (arguments have type nil, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexNilFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, 1.5)`, env,
		`invalid operation: complex(nil, 1.5) (mismatched types nil and untyped number)`,
	)
}
func TestCheckBuiltinComplexNilSlice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, []int{})`, env,
		`invalid operation: complex(nil, []int literal) (arguments have type []int, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexNilMap(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, map[int]int{})`, env,
		`invalid operation: complex(nil, map[int]int literal) (arguments have type map[int]int, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexNilType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, int)`, env,
		`type int is not an expression`,
	)
}
func TestCheckBuiltinComplexNilMakeType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, map[int]int)`, env,
		`type map[int]int is not an expression`,
	)
}
func TestCheckBuiltinComplexNilDouble(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, 1, 1)`, env,
		`too many arguments to complex - complex(nil, <N>)`,
	)
}
func TestCheckBuiltinComplexNilEllipsis(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(nil, []int{1,2}...)`, env,
		`invalid use of ... with builtin complex`,
		`invalid operation: complex(nil, []int literal) (arguments have type []int, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexFloatX(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5)`, env,
		`missing argument to complex - complex(1.5, <N>)`,
	)
}
func TestCheckBuiltinComplexFloatInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1.5, 1)`, env, complex(1.5, 1), reflect.TypeOf(complex(1.5, 1)))
}
func TestCheckBuiltinComplexFloatFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1.5, float32(1))`, env, complex(1.5, float32(1)), reflect.TypeOf(complex(1.5, float32(1))))
}
func TestCheckBuiltinComplexFloatString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, "abc")`, env,
		`invalid operation: complex(1.5, "abc") (mismatched types untyped number and untyped string)`,
	)
}
func TestCheckBuiltinComplexFloatNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, nil)`, env,
		`invalid operation: complex(1.5, nil) (mismatched types untyped number and nil)`,
	)
}
func TestCheckBuiltinComplexFloatFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectConst(t, `complex(1.5, 1.5)`, env, complex(1.5, 1.5), reflect.TypeOf(complex(1.5, 1.5)))
}
func TestCheckBuiltinComplexFloatSlice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, []int{})`, env,
		`invalid operation: complex(1.5, []int literal) (mismatched types float64 and []int)`,
	)
}
func TestCheckBuiltinComplexFloatMap(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, map[int]int{})`, env,
		`invalid operation: complex(1.5, map[int]int literal) (mismatched types float64 and map[int]int)`,
	)
}
func TestCheckBuiltinComplexFloatType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, int)`, env,
		`type int is not an expression`,
	)
}
func TestCheckBuiltinComplexFloatMakeType(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, map[int]int)`, env,
		`type map[int]int is not an expression`,
	)
}
func TestCheckBuiltinComplexFloatDouble(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, 1, 1)`, env,
		`too many arguments to complex - complex(1.5, <N>)`,
	)
}
func TestCheckBuiltinComplexFloatEllipsis(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex(1.5, []int{1,2}...)`, env,
		`invalid use of ... with builtin complex`,
		`invalid operation: complex(1.5, []int literal) (mismatched types float64 and []int)`,
	)
}
func TestCheckBuiltinComplexSliceX(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{})`, env,
		`missing argument to complex - complex(composite literal, <N>)`,
	)
}
func TestCheckBuiltinComplexSliceInt(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, 1)`, env,
		`invalid operation: complex([]int literal, 1) (mismatched types []int and int)`,
	)
}
func TestCheckBuiltinComplexSliceFloat32(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, float32(1))`, env,
		`invalid operation: complex([]int literal, float32(1)) (mismatched types []int and float32)`,
	)
}
func TestCheckBuiltinComplexSliceString(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, "abc")`, env,
		`invalid operation: complex([]int literal, "abc") (mismatched types []int and string)`,
	)
}
func TestCheckBuiltinComplexSliceNil(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, nil)`, env,
		`invalid operation: complex([]int literal, nil) (arguments have type []int, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexSliceFloat(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, 1.5)`, env,
		`invalid operation: complex([]int literal, 1.5) (mismatched types []int and float64)`,
	)
}
func TestCheckBuiltinComplexSliceSlice(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, []int{})`, env,
		`invalid operation: complex([]int literal, []int literal) (arguments have type []int, expected floating-point)`,
	)
}
func TestCheckBuiltinComplexSliceMap(t *testing.T) {
	env := MakeSimpleEnv()
	expectCheckError(t, `complex([]int{}, map[int]int{})`, env,
		`invalid operation: complex([]int literal, map[int]int literal) (mismatched types []int and map[int]int)`,
	)
}