reflect: Implement FieldByNameFunc in terms of VisibleFields

This simplifies things quite a bit, and ensures that the output of
FieldByNameFunc() always agrees with the output of VisibleFields().  To
simplify it even further, define FieldByName() in terms of
FieldByNameFunc(), passing it a closure.

Signed-off-by: L. Pereira <[email protected]>

Author: lpereira

src/reflect/type.go

@@ -724,100 +724,6 @@ func (t *rawType) rawField(n int) rawStructField {
 	return rawStructFieldFromPointer(descriptor, field.fieldType, data, flagsByte, name, offset)
 }
 
-// rawFieldByNameFunc returns nearly the same value as FieldByNameFunc but without converting the
-// Type member to an interface.
-//
-// For internal use only.
-func (t *rawType) rawFieldByNameFunc(match func(string) bool) (rawStructField, []int, bool) {
-	if t.Kind() != Struct {
-		panic(errTypeField)
-	}
-
-	type fieldWalker struct {
-		t     *rawType
-		index []int
-	}
-
-	queue := make([]fieldWalker, 0, 4)
-	queue = append(queue, fieldWalker{t, nil})
-
-	for len(queue) > 0 {
-		type result struct {
-			r     rawStructField
-			index []int
-		}
-
-		var found []result
-		var nextlevel []fieldWalker
-
-		// For all the structs at this level..
-		for _, ll := range queue {
-			// Iterate over all the fields looking for the matching name
-			// Also calculate field offset.
-
-			descriptor := (*structType)(unsafe.Pointer(ll.t.underlying()))
-			field := &descriptor.fields[0]
-
-			for i := uint16(0); i < descriptor.numField; i++ {
-				data := field.data
-
-				// Read some flags of this field, like whether the field is an embedded
-				// field. See structFieldFlagAnonymous and similar flags.
-				flagsByte := *(*byte)(data)
-				data = unsafe.Add(data, 1)
-
-				offset, lenOffs := uvarint32(unsafe.Slice((*byte)(data), maxVarintLen32))
-				data = unsafe.Add(data, lenOffs)
-
-				name := readStringZ(data)
-				data = unsafe.Add(data, len(name))
-				if match(name) {
-					found = append(found, result{
-						rawStructFieldFromPointer(descriptor, field.fieldType, data, flagsByte, name, offset),
-						append(ll.index, int(i)),
-					})
-				}
-
-				structOrPtrToStruct := field.fieldType.Kind() == Struct || (field.fieldType.Kind() == Pointer && field.fieldType.elem().Kind() == Struct)
-				if flagsByte&structFieldFlagIsEmbedded == structFieldFlagIsEmbedded && structOrPtrToStruct {
-					embedded := field.fieldType
-					if embedded.Kind() == Pointer {
-						embedded = embedded.elem()
-					}
-
-					nextlevel = append(nextlevel, fieldWalker{
-						t:     embedded,
-						index: append(ll.index, int(i)),
-					})
-				}
-
-				// update offset/field pointer if there *is* a next field
-				if i < descriptor.numField-1 {
-					// Increment pointer to the next field.
-					field = (*structField)(unsafe.Add(unsafe.Pointer(field), unsafe.Sizeof(structField{})))
-				}
-			}
-		}
-
-		// found multiple hits at this level
-		if len(found) > 1 {
-			return rawStructField{}, nil, false
-		}
-
-		// found the field we were looking for
-		if len(found) == 1 {
-			r := found[0]
-			return r.r, r.index, true
-		}
-
-		// else len(found) == 0, move on to the next level
-		queue = append(queue[:0], nextlevel...)
-	}
-
-	// didn't find it
-	return rawStructField{}, nil, false
-}
-
 // Bits returns the number of bits that this type uses. It is only valid for
 // arithmetic types (integers, floats, and complex numbers). For other types, it
 // will panic.
@@ -1096,46 +1002,36 @@ func (t *rawType) PkgPath() string {
 	return ""
 }
 
+//go:inline
 func (t *rawType) FieldByName(name string) (StructField, bool) {
-	if t.Kind() != Struct {
-		panic(errTypeFieldByName)
-	}
-
-	field, index, ok := t.rawFieldByNameFunc(func(n string) bool { return n == name })
-	if !ok {
-		return StructField{}, false
-	}
-
-	return StructField{
-		Name:      field.Name,
-		PkgPath:   field.PkgPath,
-		Type:      field.Type, // note: converts rawType to Type
-		Tag:       field.Tag,
-		Anonymous: field.Anonymous,
-		Offset:    field.Offset,
-		Index:     index,
-	}, true
+	return t.FieldByNameFunc(func(n string) bool { return n == name })
 }
 
 func (t *rawType) FieldByNameFunc(match func(string) bool) (StructField, bool) {
 	if t.Kind() != Struct {
 		panic(TypeError{"FieldByNameFunc"})
 	}
 
-	field, index, ok := t.rawFieldByNameFunc(match)
-	if !ok {
-		return StructField{}, false
+	var matchedField *StructField
+	for _, field := range VisibleFields(Type(t)) {
+		if !match(field.Name) {
+			continue
+		}
+
+		if matchedField == nil || len(field.Index) < len(matchedField.Index) {
+			// First hit, or hit is in a shallower level
+			matchedField = &field
+		} else if len(field.Index) == len(matchedField.Index) {
+			// Multiple hits at this level
+			break
+		}
 	}
 
-	return StructField{
-		Name:      field.Name,
-		PkgPath:   field.PkgPath,
-		Type:      field.Type, // note: converts rawType to Type
-		Tag:       field.Tag,
-		Anonymous: field.Anonymous,
-		Offset:    field.Offset,
-		Index:     index,
-	}, true
+	if matchedField != nil {
+		return *matchedField, true
+	}
+
+	return StructField{}, false
 }
 
 func (t *rawType) FieldByIndex(index []int) StructField {