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.

These methods have been introduced into the reflect package (as well
as tests) replacing three-clause for loops where possible.

Fixes #66631

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/abi_test.go

@@ -175,8 +175,8 @@ func TestReflectCallABI(t *testing.T) {
 				t.Fatalf("test case has different number of inputs and outputs: %d in, %d out", typ.NumIn(), typ.NumOut())
 			}
 			var args []reflect.Value
-			for i := 0; i < typ.NumIn(); i++ {
-				args = append(args, genValue(t, typ.In(i), r))
+			for arg := range typ.Ins() {
+				args = append(args, genValue(t, arg, r))
 			}
 			results := fn.Call(args)
 			for i := range results {

src/reflect/all_test.go

@@ -8505,8 +8505,7 @@ func TestInitFuncTypes(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			ipT := TypeOf(net.IP{})
-			for i := 0; i < ipT.NumMethod(); i++ {
-				_ = ipT.Method(i)
+			for range ipT.Methods() {
 			}
 		}()
 	}

src/reflect/benchmark_test.go

@@ -146,10 +146,8 @@ func BenchmarkIsZero(b *testing.B) {
 	s.ArrayInt_1024_NoZero[512] = 1
 	source := ValueOf(s)
 
-	for i := 0; i < source.NumField(); i++ {
-		name := source.Type().Field(i).Name
-		value := source.Field(i)
-		b.Run(name, func(b *testing.B) {
+	for field, value := range source.Fields() {
+		b.Run(field.Name, func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				sink = value.IsZero()
 			}
@@ -175,9 +173,8 @@ func BenchmarkSetZero(b *testing.B) {
 		Struct    Value
 	})).Elem()
 
-	for i := 0; i < source.NumField(); i++ {
-		name := source.Type().Field(i).Name
-		value := source.Field(i)
+	for field, value := range source.Fields() {
+		name := field.Name
 		zero := Zero(value.Type())
 		b.Run(name+"/Direct", func(b *testing.B) {
 			for i := 0; i < b.N; i++ {

src/reflect/example_test.go

@@ -96,8 +96,7 @@ func ExampleStructTag_Lookup() {
 
 	s := S{}
 	st := reflect.TypeOf(s)
-	for i := 0; i < st.NumField(); i++ {
-		field := st.Field(i)
+	for field := range st.Fields() {
 		if alias, ok := field.Tag.Lookup("alias"); ok {
 			if alias == "" {
 				fmt.Println("(blank)")

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.
@@ -3221,8 +3263,8 @@ func (v Value) Comparable() bool {
 		return v.IsNil() || v.Elem().Comparable()
 
 	case Struct:
-		for i := 0; i < v.NumField(); i++ {
-			if !v.Field(i).Comparable() {
+		for _, value := range v.Fields() {
+			if !value.Comparable() {
 				return false
 			}
 		}