The new methods synonymous with the method of the same name
in [Value] are added to [Type]:
1. [Type.OverflowComplex]
2. [Type.OverflowFloat]
3. [Type.OverflowInt]

pkg reflect, method (Value) Seq2() iter.Seq2[Value, Value] #66056
pkg reflect, type Type interface, CanSeq() bool #66056
pkg reflect, type Type interface, CanSeq2() bool #66056
pkg reflect, type Type interface, OverflowComplex(complex128) bool #60427
pkg reflect, type Type interface, OverflowFloat(float64) bool #60427
pkg reflect, type Type interface, OverflowInt(int64) bool #60427
pkg reflect, type Type interface, OverflowUint(uint64) bool #60427

			"Value.Complex",
			"Value.Float",
			"Value.Int",
			"Value.Interface",
			"Value.IsNil",
			"Value.IsValid",
			"Value.Kind",
			"Value.Len",
			"Value.MapRange",
			"Value.OverflowComplex",
			"Value.OverflowFloat",
			"Value.OverflowInt",
			"Value.OverflowUint",
			"Value.String",
			"Value.Type",
			"Value.Uint",
			"Value.UnsafeAddr",
			"Value.pointer",
			"add",

 func (v <type 1>) Method (i <type -11>) <type 1>;
 func (v <type 1>) NumMethod () <type -11>;
 func (v <type 1>) MethodByName (name <type -16>) <type 1>;
 func (v <type 1>) NumField () <type -11>;
 func (v <type 1>) OverflowComplex (x <type -18>) <type -15>;
 func (v <type 1>) OverflowFloat (x <type -10>) <type -15>;
 func (v <type 1>) OverflowInt (x <type -4>) <type -15>;
 func (v <type 1>) OverflowUint (x <type -8>) <type -15>;

	// It panics if the type's Kind is not Func.
	// It panics if i is not in the range [0, NumOut()).
	Out(i int) Type

	// OverflowComplex reports whether the complex128 x cannot be represented by type t.
	// It panics if t's Kind is not Complex64 or Complex128.
	OverflowComplex(x complex128) bool

	// OverflowFloat reports whether the float64 x cannot be represented by type t.

	v.mustBe(Struct)
	tt := (*structType)(unsafe.Pointer(v.typ()))
	return len(tt.Fields)
}

// OverflowComplex reports whether the complex128 x cannot be represented by v's type.
// It panics if v's Kind is not [Complex64] or [Complex128].
func (v Value) OverflowComplex(x complex128) bool {
	k := v.kind()
	switch k {
	case Complex64:
		return overflowFloat32(real(x)) || overflowFloat32(imag(x))

	shouldPanic("call of reflect.Value.NumMethod on zero Value", func() { vo(nil).NumMethod() })
	shouldPanic("call of reflect.Value.OverflowComplex on float64 Value", func() { vo(float64(0)).OverflowComplex(0) })
	shouldPanic("call of reflect.Value.OverflowFloat on int64 Value", func() { vo(int64(0)).OverflowFloat(0) })

		{"(Value).MapRange", Method, 12},
		{"(Value).Method", Method, 0},
		{"(Value).MethodByName", Method, 0},
		{"(Value).NumField", Method, 0},
		{"(Value).NumMethod", Method, 0},
		{"(Value).OverflowComplex", Method, 0},
		{"(Value).OverflowFloat", Method, 0},
		{"(Value).OverflowInt", Method, 0},
		{"(Value).OverflowUint", Method, 0},
		{"(Value).Pointer", Method, 0},
		{"(Value).Recv", Method, 0},

pkg reflect, method (Value) Method(int) Value
pkg reflect, method (Value) MethodByName(string) Value
pkg reflect, method (Value) NumField() int
pkg reflect, method (Value) NumMethod() int
pkg reflect, method (Value) OverflowComplex(complex128) bool
pkg reflect, method (Value) OverflowFloat(float64) bool
pkg reflect, method (Value) OverflowInt(int64) bool
pkg reflect, method (Value) OverflowUint(uint64) bool