type IntegerType interface {
	int8 | int16 | int32 | int64 | int |
		uint8 | uint16 | uint32 | uint64 | uint
}

type ComplexType interface {
	complex64 | complex128
}

type Number interface {
	FloatType | IntegerType | ComplexType
}

func GetDefaultNumber[T Number](value, defaultValue T) T {
	if value == 0 {
		return defaultValue
	}
	return value

// license that can be found in the LICENSE file.

package cmplx

import "math"

// Rect returns the complex number x with polar coordinates r, θ.
func Rect(r, θ float64) complex128 {
	s, c := math.Sincos(θ)
	return complex(r*c, r*s)

import (
	"math"
)

// Global variables without initialization
var (
	a, b bool
	c byte
	d uint8
	r rune
	i int
	j, k, l int
	x, y float32
	xx, yy float64
	u, v complex64
	uu, vv complex128
	s, t string
	array []byte
	iface interface{}

	blank _ /* ERROR "cannot use _" */
)

// Global variables with initialization
var (
	s1 = i + j
	s2 = i /* ERROR "mismatched types" */ + x

//
// REGISTER_OP("Add")
//     .Input("x: T")
//     .Input("y: T")
//     .Output("z: T")
//     .Attr(
//         "T: {bfloat16, half, float, double, uint8, int8, int16, int32, int64, "
//         "complex64, complex128, string}")
tfr.func @tf__add_(!tfr.tensor<T>, !tfr.tensor<T>)
    -> !tfr.tensor<T> attributes{T}

// Translated from:
//
// REGISTER_OP("MatMul")
//     .Input("a: T")
//     .Input("b: T")

package p

var b struct {
	a[10]int
}

var m map[string][20]int

var s [][30]int

func f() *[40]int
var c chan *[50]int
var z complex128

const (
	n1 = len(b.a)
	n2 = len(m[""])
	n3 = len(s[10])

	n4 = len(f())  // ERROR "is not a constant|is not constant"
	n5 = len(<-c) // ERROR "is not a constant|is not constant"

// license that can be found in the LICENSE file.

// Issue 12525: confusing error trying to increment boolean value

package main

func main() {
	var i int
	i++

	var f float64
	f++

	var c complex128
	c++

	var b bool
	b++ // ERROR "invalid operation: b\+\+ \(non-numeric type bool\)"

	var s string
	s-- // ERROR "invalid operation: s-- \(non-numeric type string\)"

	MOVO	x+0(FP), X0 // ERROR "\[amd64\] cpx: invalid MOVO of x\+0\(FP\); complex64 is 8-byte value containing x_real\+0\(FP\) and x_imag\+4\(FP\)"

	const (
		a = 1 + iota // ERROR "invalid operation|incompatible types|cannot convert"
	)
	_, _ = n, y
}

const (
	append     = 1
	bool       = 2
	byte       = 3
	complex    = 4
	complex64  = 5
	complex128 = 6
	cap        = 7
	close      = 8
	delete     = 9
	error      = 10
	false      = 11
	float32    = 12
	float64    = 13
	imag       = 14
	int        = 15
	int8       = 16
	int16      = 17

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package runtime_test

import (
	"math/cmplx"
	"testing"
)

var result complex128

func BenchmarkComplex128DivNormal(b *testing.B) {
	d := 15 + 2i
	n := 32 + 3i
	res := 0i
	for i := 0; i < b.N; i++ {
		n += 0.1i
		res += n / d
	}
	result = res
}

// license that can be found in the LICENSE file.

package main

type T struct {
	// legal according to spec
	x int
	y (int)
	int
	*float64
	// not legal according to spec
	(complex128)  // ERROR "non-declaration|expected|parenthesize"
	(*string)  // ERROR "non-declaration|expected|parenthesize"
	*(bool)    // ERROR "non-declaration|expected|parenthesize"
}

// legal according to spec