reflect: add iterator equivalents for NumField, NumIn, NumOut and NumMethod

The new methods are Type.Fields, Type.Methods, Type.Ins, Type.Outs,
Value.Fields and Value.Methods.

Fixes #66631

address comments

fix the obvious case

Author: Splizard

api/next/66631.txt

@@ -0,0 +1,6 @@
+pkg reflect, type Type interface, Fields() iter.Seq[StructField] #66631
+pkg reflect, type Type interface, Methods() iter.Seq[Method] #66631
+pkg reflect, type Type interface, Ins() iter.Seq[Type] #66631
+pkg reflect, type Type interface, Outs() iter.Seq[Type] #66631
+pkg reflect, method (Value) Fields() iter.Seq2[StructField, Value] #66631
+pkg reflect, method (Value) Methods() iter.Seq2[Method, Value] #66631

src/reflect/type.go

@@ -18,6 +18,7 @@ package reflect
 import (
 	"internal/abi"
 	"internal/goarch"
+	"iter"
 	"runtime"
 	"strconv"
 	"sync"
@@ -255,6 +256,22 @@ type Type interface {
 	// CanSeq2 reports whether a [Value] with this type can be iterated over using [Value.Seq2].
 	CanSeq2() bool
 
+	// Fields yields each field of a struct type.
+	// It panics if the type's Kind is not Struct.
+	Fields() iter.Seq[StructField]
+
+	// Methods yields each method in the type's method set.
+	// See [Type.Method] for information on the yielded methods.
+	Methods() iter.Seq[Method]
+
+	// Ins yields each input parameter of a function type, in order.
+	// It panics if the type's Kind is not Func.
+	Ins() iter.Seq[Type]
+
+	// Outs yields each output parameter of a function type, in order.
+	// It panics if the type's Kind is not Func.
+	Outs() iter.Seq[Type]
+
 	common() *abi.Type
 	uncommon() *uncommonType
 }
@@ -934,6 +951,46 @@ func canRangeFunc2(t *abi.Type) bool {
 	return yield.InCount == 2 && yield.OutCount == 1 && yield.Out(0).Kind() == abi.Bool
 }
 
+func (t *rtype) Fields() iter.Seq[StructField] {
+	return func(yield func(StructField) bool) {
+		for i := range t.NumField() {
+			if !yield(t.Field(i)) {
+				return
+			}
+		}
+	}
+}
+
+func (t *rtype) Methods() iter.Seq[Method] {
+	return func(yield func(Method) bool) {
+		for i := range t.NumMethod() {
+			if !yield(t.Method(i)) {
+				return
+			}
+		}
+	}
+}
+
+func (t *rtype) Ins() iter.Seq[Type] {
+	return func(yield func(Type) bool) {
+		for i := range t.NumIn() {
+			if !yield(t.In(i)) {
+				return
+			}
+		}
+	}
+}
+
+func (t *rtype) Outs() iter.Seq[Type] {
+	return func(yield func(Type) bool) {
+		for i := range t.NumOut() {
+			if !yield(t.Out(i)) {
+				return
+			}
+		}
+	}
+}
+
 // add returns p+x.
 //
 // The whySafe string is ignored, so that the function still inlines

src/reflect/value.go

@@ -10,6 +10,7 @@ import (
 	"internal/goarch"
 	"internal/itoa"
 	"internal/unsafeheader"
+	"iter"
 	"math"
 	"runtime"
 	"unsafe"
@@ -2620,6 +2621,47 @@ func (v Value) UnsafePointer() unsafe.Pointer {
 	panic(&ValueError{"reflect.Value.UnsafePointer", v.kind()})
 }
 
+// Fields yields each field of v, along with its description.
+//
+// It panics if v's Kind is not Struct.
+//
+// The i'th field yielded by Fields is the same as [Type.Field(i)] and [Value.Field(i)].
+func (v Value) Fields() iter.Seq2[StructField, Value] {
+	return func(yield func(StructField, Value) bool) {
+		rtype := v.Type()
+		for i := range v.NumField() {
+			if !yield(rtype.Field(i), v.Field(i)) {
+				return
+			}
+		}
+	}
+}
+
+// Methods yields a function value corresponding to each method of v,
+// along with a description of the method.
+//
+// The arguments to a Call on the yielded function value should not include a receiver;
+// the returned function will always use v as the receiver. Note that [Method.Type]
+// in each yielded [Method] does include the receiver, and thus is not the same as
+// [Value.Type].
+//
+// Methods panics if v is a nil interface value.
+//
+// The i'th method yielded by Methods is the same as [Type.Method(i)] and [Value.Method(i)].
+//
+// Calling this method will force the linker to retain all exported methods in all packages.
+// This may make the executable binary larger but will not affect execution time.
+func (v Value) Methods() iter.Seq2[Method, Value] {
+	return func(yield func(Method, Value) bool) {
+		rtype := v.Type()
+		for i := range v.NumMethod() {
+			if !yield(rtype.Method(i), v.Method(i)) {
+				return
+			}
+		}
+	}
+}
+
 // StringHeader is the runtime representation of a string.
 // It cannot be used safely or portably and its representation may
 // change in a later release.