"uint32, uint64, int8, int16, complex64, complex128, qint8, quint8, "
      "qint16, quint16, qint32}");
  TF_OpDefinitionBuilderAddAttr(
      op_builder,
      "type: {bfloat16, half, float, double, int64, int32, uint8, uint16, "
      "uint32, uint64, int8, int16, complex64, complex128, qint8, quint8, "
      "qint16, quint16, qint32}");

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

// Issue 1716

package main

type (
	cplx64  complex64
	cplx128 complex128
)

func (c cplx64) Foo()  {}
func (c cplx128) Foo() {}

func main() {
	var c64 cplx128
	var c128 cplx64
	c64.Foo()
	c128.Foo()
}

/*
bug334.go:16: invalid receiver type cplx64

// Copyright 2022 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.

package b

import "./a"

func F() complex128 {
	return a.F()

// Copyright 2023 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.

package p

import "unsafe"

type E [1 << 30]complex128

var a [1 << 30]E
var _ = unsafe.Sizeof(a) // ERROR "too large"

var s struct {
	_ [1 << 30]E
	x int
}
var _ = unsafe.Offsetof(s.x) // ERROR "too large"

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

func DotProduct[T Numeric](s1, s2 []T) T {
	if len(s1) != len(s2) {
		panic("DotProduct: slices of unequal length")
	}
	var r T
	for i := range s1 {
		r += s1[i] * s2[i]
	}
	return r
}

package p

func g[P any](...P) P { var x P; return x }

func _() {
	var (
		_ int        = g(1, 2)
		_ rune       = g(1, 'a')
		_ float64    = g(1, 'a', 2.3)
		_ float64    = g('a', 2.3)
		_ complex128 = g(2.3, 'a', 1i)
	)
	g(true, 'a' /* ERROR "mismatched types untyped bool and untyped rune (cannot infer P)" */)
	g(1, "foo" /* ERROR "mismatched types untyped int and untyped string (cannot infer P)" */)

	_ = 1 < 2i  // ERROR "invalid operation: .*not defined on untyped complex|non-ordered type"

	c := 1i
	_ = c < 2i // ERROR "invalid operation: .*not defined on complex128|non-ordered type"

var ix int
var i0 = 0
var i1 = 1

var jx uint
var j0 = uint(0)
var j1 = uint(1)

var cx complex64
var c0 = complex64(0)
var c1 = complex64(1)

var dx complex128
var d0 = complex128(0)
var d1 = complex128(1)

var sx []int
var s0 = []int{0, 0, 0}
var s1 = []int{1, 2, 3}

func fi() int { return 1 }

var ax [10]int
var a0 = [10]int{0, 0, 0}
var a1 = [10]int{1, 2, 3, 4}

	}
	return a
}

// Complex matches the two complex types, which do not have a < operator.
type Complex interface {
	~complex64 | ~complex128
}

func realimag(x any) (re, im float64) {
	switch z := x.(type) {
	case complex64:
		re = float64(real(z))
		im = float64(imag(z))
	case complex128:
		re = real(z)
		im = imag(z)
	default:
		panic("unknown complex type")
	}
	return
}

func f(x int, m map[string]int) {
	// no values
	_ = f /* ERROR "f(0, m) (no value) used as value" */ (0, m)

	// built-ins
	_ = println // ERROR "println (built-in) must be called"

	// types
	_ = complex128 // ERROR "complex128 (type) is not an expression"

	// constants
	const c1 = 991
	const c2 float32 = 0.5
	const c3 = "foo"
	0 // ERROR "0 (untyped int constant) is not used"