#81 handle field name conflict properly

feature_reflect_extension.go

@@ -31,6 +31,7 @@ func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding {
 }
 
 type Binding struct {
+	levels    []int
 	Field     *reflect.StructField
 	FromNames []string
 	ToNames   []string
@@ -206,6 +207,7 @@ func describeStruct(cfg *frozenConfig, typ reflect.Type) (*StructDescriptor, err
 					return nil, err
 				}
 				for _, binding := range structDescriptor.Fields {
+					binding.levels = append([]int{i}, binding.levels...)
 					binding.Encoder = &structFieldEncoder{&field, binding.Encoder, false}
 					binding.Decoder = &structFieldDecoder{&field, binding.Decoder}
 					if field.Offset == 0 {
@@ -221,12 +223,11 @@ func describeStruct(cfg *frozenConfig, typ reflect.Type) (*StructDescriptor, err
 					return nil, err
 				}
 				for _, binding := range structDescriptor.Fields {
-					cloneField := field
+					binding.levels = append([]int{i}, binding.levels...)
-					cloneField.Name = binding.Field.Name
 					binding.Encoder = &optionalEncoder{binding.Encoder}
-					binding.Encoder = &structFieldEncoder{&cloneField, binding.Encoder, false}
+					binding.Encoder = &structFieldEncoder{&field, binding.Encoder, false}
 					binding.Decoder = &deferenceDecoder{field.Type.Elem(), binding.Decoder}
-					binding.Decoder = &structFieldDecoder{&cloneField, binding.Decoder}
+					binding.Decoder = &structFieldDecoder{&field, binding.Decoder}
 					if field.Offset == 0 {
 						headAnonymousBindings = append(headAnonymousBindings, binding)
 					} else {
@@ -266,6 +267,7 @@ func describeStruct(cfg *frozenConfig, typ reflect.Type) (*StructDescriptor, err
 			Decoder:   decoder,
 			Encoder:   encoder,
 		}
+		binding.levels = []int{i}
 		bindings = append(bindings, binding)
 	}
 	return createStructDescriptor(cfg, typ, bindings, headAnonymousBindings, tailAnonymousBindings), nil

feature_reflect_object.go

@@ -8,47 +8,101 @@ import (
 )
 
 func encoderOfStruct(cfg *frozenConfig, typ reflect.Type) (ValEncoder, error) {
-	fieldsByToName := map[string]int{}
+	type bindingTo struct {
-	orderedFields := []*structFieldTo{}
+		binding *Binding
+		toName  string
+		ignored bool
+	}
+	orderedBindings := []*bindingTo{}
 	structDescriptor, err := describeStruct(cfg, typ)
 	if err != nil {
 		return nil, err
 	}
-	for index, binding := range structDescriptor.Fields {
+	for _, binding := range structDescriptor.Fields {
 		for _, toName := range binding.ToNames {
-			oldIndex, found := fieldsByToName[toName]
+			new := &bindingTo{
-			if found {
+				binding: binding,
-				orderedFields[oldIndex] = nil // replaced by the later one
+				toName:  toName,
 			}
-			fieldsByToName[toName] = index
+			for _, old := range orderedBindings {
-			orderedFields = append(orderedFields, &structFieldTo{
+				if old.toName != toName {
-				binding.Encoder.(*structFieldEncoder),
+					continue
-				toName,
+				}
-			})
+				old.ignored, new.ignored = resolveConflictBinding(old.binding, new.binding)
+			}
+			orderedBindings = append(orderedBindings, new)
 		}
 	}
-	if len(orderedFields) == 0 {
+	if len(orderedBindings) == 0 {
 		return &emptyStructEncoder{}, nil
 	}
 	finalOrderedFields := []structFieldTo{}
-	for _, structFieldTo := range orderedFields {
+	for _, bindingTo := range orderedBindings {
-		if structFieldTo != nil {
+		if !bindingTo.ignored {
-			finalOrderedFields = append(finalOrderedFields, *structFieldTo)
+			finalOrderedFields = append(finalOrderedFields, structFieldTo{
+				encoder: bindingTo.binding.Encoder.(*structFieldEncoder),
+				toName:  bindingTo.toName,
+			})
 		}
 	}
 	return &structEncoder{structDescriptor.onePtrEmbedded, structDescriptor.onePtrOptimization, finalOrderedFields}, nil
 }
 
+func resolveConflictBinding(old, new *Binding) (ignoreOld, ignoreNew bool) {
+	newTagged := new.Field.Tag.Get("json") != ""
+	oldTagged := old.Field.Tag.Get("json") != ""
+	if newTagged {
+		if oldTagged {
+			if len(old.levels) > len(new.levels) {
+				return true, false
+			} else if len(new.levels) > len(old.levels) {
+				return false, true
+			} else {
+				return true, true
+			}
+		} else {
+			return true, false
+		}
+	} else {
+		if oldTagged {
+			return true, false
+		} else {
+			if len(old.levels) > len(new.levels) {
+				return true, false
+			} else if len(new.levels) > len(old.levels) {
+				return false, true
+			} else {
+				return true, true
+			}
+		}
+	}
+}
+
 func decoderOfStruct(cfg *frozenConfig, typ reflect.Type) (ValDecoder, error) {
-	fields := map[string]*structFieldDecoder{}
+	bindings := map[string]*Binding{}
 	structDescriptor, err := describeStruct(cfg, typ)
 	if err != nil {
 		return nil, err
 	}
 	for _, binding := range structDescriptor.Fields {
 		for _, fromName := range binding.FromNames {
-			fields[fromName] = binding.Decoder.(*structFieldDecoder)
+			old := bindings[fromName]
+			if old == nil {
+				bindings[fromName] = binding
+				continue
 			}
+			ignoreOld, ignoreNew := resolveConflictBinding(old, binding)
+			if ignoreOld {
+				delete(bindings, fromName)
+			}
+			if !ignoreNew {
+				bindings[fromName] = binding
+			}
+		}
+	}
+	fields := map[string]*structFieldDecoder{}
+	for k, binding := range bindings {
+		fields[k] = binding.Decoder.(*structFieldDecoder)
 	}
 	return createStructDecoder(typ, fields)
 }