"testing"
)

func TestTypeFor(t *testing.T) {
	type (
		mystring string
		myiface  interface{}
	)

	testcases := []struct {
		wantFrom any
		got      reflect.Type
	}{
		{new(int), reflect.TypeFor[int]()},
		{new(int64), reflect.TypeFor[int64]()},
		{new(string), reflect.TypeFor[string]()},
		{new(mystring), reflect.TypeFor[mystring]()},
		{new(any), reflect.TypeFor[any]()},

type MyInt32 int32
type MyInt64 int64
type MyString string
type MyUint uint
type MyUint8 uint8
type MyUint16 uint16
type MyUint32 uint32
type MyUint64 uint64
type MyUintptr uintptr

func panicCustomComplex64() {
	panic(MyComplex64(0.11 + 3i))
}

func panicCustomComplex128() {
	panic(MyComplex128(32.1 + 10i))
}

func panicCustomString() {
	panic(MyString("Panic\nline two"))
}

	z = z /* ERRORx `operand z .* must be integer` */ >> y
}

type mystring string

func _(x, y string, z mystring) {
	x = x + "foo"
	x = x /* ERROR "not defined" */ - "foo"
	x = x /* ERROR "mismatched types string and untyped int" */ + 1
	x = x + y
	x = x /* ERROR "not defined" */ - y
	x = x /* ERROR "mismatched types string and untyped int" */* 10
}

func f() (a, b int) { return }

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

// Test interfaces on basic types.

package main

type myint int
type mystring string
type I0 interface{}

func f() {
	var ia, ib I0
	var i myint
	var s mystring

	if ia != ib {
		panic("1")
	}

	i = 1
	ia = i
	ib = i
	if ia != ib {
		panic("2")
	}
	if ia == nil {
		panic("3")
	}

	i = 2

}

// "x is an integer or a slice of bytes or runes and T is a string type"

type myInt int
type myString string

func _[T ~string](x int) T      { return T(x) }
func _[T ~string](x myInt) T    { return T(x) }
func _[X Integer](x X) string   { return string(x) }
func _[X Integer](x X) myString { return myString(x) }
func _[X Integer](x X) *string {

// when the underlying kind is directly printable.
// Issue: https://golang.org/issues/37531
func TestPanicWithDirectlyPrintableCustomTypes(t *testing.T) {
	tests := []struct {
		name            string
		wantPanicPrefix string
	}{
		{"panicCustomBool", `panic: main.MyBool(true)`},
		{"panicCustomComplex128", `panic: main.MyComplex128(+3.210000e+001+1.000000e+001i)`},

	return x + 1
}

type MyString string
func double[T interface{MyInt|MyString}](x T) T {
	return x + x
}

// Embedding of interfaces with term lists leads to interfaces
// with term lists that are the intersection of the embedded
// term lists.

type E0 interface {
	~int | ~bool | ~string
}

type E1 interface {
	~int | ~float64 | ~string
}

type E2 interface {
	~float64

	{V(MyString("hello")), V(string("hello"))},
	{V(string("hello")), V(MyString("hello"))},
	{V(string("hello")), V(string("hello"))},
	{V(MyString("hello")), V(MyString("hello"))},
	{V(MyString("bytes1")), V([]byte("bytes1"))},
	{V([]byte("bytes2")), V(MyString("bytes2"))},
	{V([]byte("bytes3")), V([]byte("bytes3"))},
	{V(MyString("runes♝")), V([]rune("runes♝"))},
	{V([]rune("runes♕")), V(MyString("runes♕"))},

// range iteration

func _[T interface{}](x T) {
        for range x /* ERROR "cannot range" */ {}
}

type myString string

func _[
        B1 interface{ string },
        B2 interface{ string | myString },

        C1 interface{ chan int },
        C2 interface{ chan int | <-chan int },
        C3 interface{ chan<- int },

        S1 interface{ []int },

	_ = c[3 /* ERRORx `index .* out of bounds` */ ]
	_ = ""[0 /* ERRORx `index .* out of bounds` */ ]
	_ = c2

	_ = s[1<<30] // no compile-time error here

	// issue 4913
	type mystring string
	var ss string
	var ms mystring
	var i, j int
	ss = "foo"[1:2]
	ss = "foo"[i:j]
	ms = "foo" /* ERRORx `cannot use .* in assignment` */ [1:2]
	ms = "foo" /* ERRORx `cannot use .* in assignment` */ [i:j]
	_, _ = ss, ms