n

Change-Id: I1a5b0506d1f8a35e4a89ba9cf2700ab9be3ddfee

Author: qiulaidongfeng

doc/next/6-stdlib/99-minor/reflect/66056.md

@@ -1,3 +1,3 @@
 The new method add a similar for range capability.
-[Type.CanSeq]/[Type.CanSeq2] report whether the type is convertible to [iter.Seq]/[iter.Seq2].
-[Value.Seq] and [Value.Seq2] Similar to reflection for range of a value.
+[Type.CanSeq] and [Type.CanSeq2] whether the report type can be use for range.
+[Value.Seq] and [Value.Seq2] similar for range a value.

src/reflect/all_test.go

@@ -8712,6 +8712,22 @@ func TestValueSeq(t *testing.T) {
 				}
 			}
 		}},
+		{"func", ValueOf(func(f func(int) bool) {
+			for i := range 4 {
+				f(i)
+			}
+		}), func(t *testing.T, s iter.Seq[Value]) {
+			i := int64(0)
+			for v := range s {
+				if v.Int() != i {
+					t.Fatalf("got %d, want %d", v.Int(), i)
+				}
+				i++
+				if i > 4 {
+					t.Fatalf("should loop four times")
+				}
+			}
+		}},
 	}
 	for _, tc := range tests {
 		seq := tc.val.Seq()
@@ -8808,6 +8824,25 @@ func TestValueSeq2(t *testing.T) {
 				}
 			}
 		}},
+		{"func", ValueOf(func(f func(int, int) bool) {
+			for i := range 4 {
+				f(i, i+1)
+			}
+		}), func(t *testing.T, s iter.Seq2[Value, Value]) {
+			i := int64(0)
+			for v1, v2 := range s {
+				if v1.Int() != i {
+					t.Fatalf("got %d, want %d", v1.Int(), i)
+				}
+				i++
+				if i > 4 {
+					t.Fatalf("should loop four times")
+				}
+				if v2.Int() != i {
+					t.Fatalf("got %d, want %d", v2.Int(), i)
+				}
+			}
+		}},
 	}
 	for _, tc := range tests {
 		seq := tc.val.Seq2()

src/reflect/type.go

@@ -241,10 +241,10 @@ type Type interface {
 	// It panics if t's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
 	OverflowUint(x uint64) bool
 
-	// CanSeq report whether the type is convertible to iter.Seq.
+	// CanSeq whether the report type can be use for range one iteration variables.
 	CanSeq() bool
 
-	// CanSeq2 report whether the type is convertible to iter.Seq2.
+	// CanSeq2 whether the report type can be use for range two iteration variables.
 	CanSeq2() bool
 
 	common() *abi.Type
@@ -873,10 +873,18 @@ func (t *rtype) OverflowUint(x uint64) bool {
 }
 
 func (t *rtype) CanSeq() bool {
-	return canSeq(&t.t)
+	switch t.Kind() {
+	case Int8, Int16, Int32, Int64, Int, Uint8, Uint16, Uint32, Uint64, Uint, Uintptr, Array, Slice, Chan, String, Map:
+		return true
+	case Func:
+		return canRangeFunc(&t.t)
+	case Pointer:
+		return t.Elem().Kind() == Array
+	}
+	return false
 }
 
-func canSeq(t *abi.Type) bool {
+func canRangeFunc(t *abi.Type) bool {
 	if t.Kind() != abi.Func {
 		return false
 	}
@@ -893,10 +901,18 @@ func canSeq(t *abi.Type) bool {
 }
 
 func (t *rtype) CanSeq2() bool {
-	return canSeq2(&t.t)
+	switch t.Kind() {
+	case Array, Slice, String, Map:
+		return true
+	case Func:
+		return canRangeFunc2(&t.t)
+	case Pointer:
+		return t.Elem().Kind() == Array
+	}
+	return false
 }
 
-func canSeq2(t *abi.Type) bool {
+func canRangeFunc2(t *abi.Type) bool {
 	if t.Kind() != abi.Func {
 		return false
 	}

src/reflect/type_test.go

@@ -126,6 +126,13 @@ func Test_Type_CanSeq(t *testing.T) {
 	}{
 		{"func(func(int) bool)", reflect.TypeOf(func(func(int) bool) {}), true},
 		{"func(func(int))", reflect.TypeOf(func(func(int)) {}), false},
+		{"int64", reflect.TypeOf(int64(1)), true},
+		{"uint64", reflect.TypeOf(uint64(1)), true},
+		{"*[4]int", reflect.TypeOf(&[4]int{}), true},
+		{"chan int64", reflect.TypeOf(make(chan int64)), true},
+		{"map[int]int", reflect.TypeOf(make(map[int]int)), true},
+		{"string", reflect.TypeOf(""), true},
+		{"[]int", reflect.TypeOf([]int{}), true},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -144,6 +151,13 @@ func Test_Type_CanSeq2(t *testing.T) {
 	}{
 		{"func(func(int, int) bool)", reflect.TypeOf(func(func(int, int) bool) {}), true},
 		{"func(func(int, int))", reflect.TypeOf(func(func(int, int)) {}), false},
+		{"int64", reflect.TypeOf(int64(1)), false},
+		{"uint64", reflect.TypeOf(uint64(1)), false},
+		{"*[4]int", reflect.TypeOf(&[4]int{}), true},
+		{"chan int64", reflect.TypeOf(make(chan int64)), false},
+		{"map[int]int", reflect.TypeOf(make(map[int]int)), true},
+		{"string", reflect.TypeOf(""), true},
+		{"[]int", reflect.TypeOf([]int{}), true},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

src/reflect/value.go

@@ -3521,7 +3521,7 @@ func (v Value) Equal(u Value) bool {
 // Otherwise v's kind must be Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr,
 // Array, Chan, Map, Slice, or String.
 func (v Value) Seq() iter.Seq[Value] {
-	if canSeq(v.typ()) {
+	if canRangeFunc(v.typ()) {
 		return func(yield func(Value) bool) {
 			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
 				return []Value{ValueOf(yield(in[0]))}
@@ -3589,7 +3589,7 @@ func (v Value) Seq() iter.Seq[Value] {
 
 // Seq2 is like Seq but for two values.
 func (v Value) Seq2() iter.Seq2[Value, Value] {
-	if canSeq2(v.typ()) {
+	if canRangeFunc2(v.typ()) {
 		return func(yield func(Value, Value) bool) {
 			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
 				return []Value{ValueOf(yield(in[0], in[1]))}