fix(mapstructure): add multi-tag support and regression tests

Author: DarkiT

mapstructure.go

@@ -699,7 +699,7 @@ func (d *Decoder) decodeString(name string, data any, val reflect.Value) error {
 		case reflect.Uint8:
 			var uints []uint8
 			if dataKind == reflect.Array {
-				uints = make([]uint8, dataVal.Len(), dataVal.Len())
+				uints = make([]uint8, dataVal.Len())
 				for i := range uints {
 					uints[i] = dataVal.Index(i).Interface().(uint8)
 				}
@@ -1091,7 +1091,7 @@ func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val re
 			)
 		}
 
-		tagValue := f.Tag.Get(d.config.TagName)
+		tagValue, _ := getTagValue(f, d.config.TagName)
 		keyName := d.config.MapFieldName(f.Name)
 
 		if tagValue == "" && d.config.IgnoreUntaggedFields {
@@ -1112,12 +1112,12 @@ func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val re
 				continue
 			}
 			// If "omitempty" is specified in the tag, it ignores empty values.
-			if strings.Index(tagValue[index+1:], "omitempty") != -1 && isEmptyValue(v) {
+			if strings.Contains(tagValue[index+1:], "omitempty") && isEmptyValue(v) {
 				continue
 			}
 
 			// If "omitzero" is specified in the tag, it ignores zero values.
-			if strings.Index(tagValue[index+1:], "omitzero") != -1 && v.IsZero() {
+			if strings.Contains(tagValue[index+1:], "omitzero") && v.IsZero() {
 				continue
 			}
 
@@ -1137,7 +1137,7 @@ func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val re
 					)
 				}
 			} else {
-				if strings.Index(tagValue[index+1:], "remain") != -1 {
+				if strings.Contains(tagValue[index+1:], "remain") {
 					if v.Kind() != reflect.Map {
 						return newDecodeError(
 							name+"."+f.Name,
@@ -1153,7 +1153,7 @@ func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val re
 				}
 			}
 
-			deep = deep || strings.Index(tagValue[index+1:], "deep") != -1
+			deep = deep || strings.Contains(tagValue[index+1:], "deep")
 
 			if keyNameTagValue := tagValue[:index]; keyNameTagValue != "" {
 				keyName = keyNameTagValue
@@ -1543,7 +1543,10 @@ func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) e
 			remain := false
 
 			// We always parse the tags cause we're looking for other tags too
-			tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
+			tagParts := getTagParts(fieldType, d.config.TagName)
+			if len(tagParts) == 0 {
+				tagParts = []string{""}
+			}
 			for _, tag := range tagParts[1:] {
 				if tag == d.config.SquashTagOption {
 					squash = true
@@ -1600,7 +1603,7 @@ func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) e
 		field, fieldValue := f.field, f.val
 		fieldName := field.Name
 
-		tagValue := field.Tag.Get(d.config.TagName)
+		tagValue, _ := getTagValue(field, d.config.TagName)
 		if tagValue == "" && d.config.IgnoreUntaggedFields {
 			continue
 		}
@@ -1784,7 +1787,7 @@ func isStructTypeConvertibleToMap(typ reflect.Type, checkMapstructureTags bool,
 		if f.PkgPath == "" && !checkMapstructureTags { // check for unexported fields
 			return true
 		}
-		if checkMapstructureTags && f.Tag.Get(tagName) != "" { // check for mapstructure tags inside
+		if checkMapstructureTags && hasAnyTag(f, tagName) { // check for mapstructure tags inside
 			return true
 		}
 	}
@@ -1812,3 +1815,36 @@ func dereferencePtrToStructIfNeeded(v reflect.Value, tagName string) reflect.Val
 		return v
 	}
 }
+
+func hasAnyTag(field reflect.StructField, tagName string) bool {
+	_, ok := getTagValue(field, tagName)
+	return ok
+}
+
+func getTagParts(field reflect.StructField, tagName string) []string {
+	tagValue, ok := getTagValue(field, tagName)
+	if !ok {
+		return nil
+	}
+	return strings.Split(tagValue, ",")
+}
+
+func getTagValue(field reflect.StructField, tagName string) (string, bool) {
+	for _, name := range splitTagNames(tagName) {
+		if tag := field.Tag.Get(name); tag != "" {
+			return tag, true
+		}
+	}
+	return "", false
+}
+
+func splitTagNames(tagName string) []string {
+	if tagName == "" {
+		return []string{"mapstructure"}
+	}
+	parts := strings.Split(tagName, ",")
+	for i, name := range parts {
+		parts[i] = strings.TrimSpace(name)
+	}
+	return parts
+}

mapstructure_test.go

@@ -3235,6 +3235,74 @@ func TestDecoder_IgnoreUntaggedFieldsWithStruct(t *testing.T) {
 	}
 }
 
+func TestDecoder_MultiTagInline(t *testing.T) {
+	type Inner struct {
+		A int `yaml:"a"`
+	}
+
+	type Wrap struct {
+		Inner `yaml:",inline"`
+	}
+
+	input := map[string]any{"a": 1}
+	var result Wrap
+
+	dec, err := NewDecoder(&DecoderConfig{
+		TagName:          "config,yaml",
+		SquashTagOption:  "inline",
+		WeaklyTypedInput: true,
+		Result:           &result,
+	})
+	if err != nil {
+		t.Fatalf("NewDecoder error: %v", err)
+	}
+
+	if err := dec.Decode(input); err != nil {
+		t.Fatalf("Decode error: %v", err)
+	}
+
+	if result.Inner.A != 1 {
+		t.Fatalf("expected inline field A=1, got %d", result.Inner.A)
+	}
+}
+
+func TestDecoder_MultiTagRemain(t *testing.T) {
+	type Wrap struct {
+		Known string         `yaml:"known"`
+		Extra map[string]any `yaml:",remain"`
+	}
+
+	input := map[string]any{
+		"known":  "ok",
+		"extra1": "v1",
+		"extra2": 2,
+	}
+	var result Wrap
+
+	dec, err := NewDecoder(&DecoderConfig{
+		TagName:          "config,yaml",
+		WeaklyTypedInput: true,
+		Result:           &result,
+	})
+	if err != nil {
+		t.Fatalf("NewDecoder error: %v", err)
+	}
+
+	if err := dec.Decode(input); err != nil {
+		t.Fatalf("Decode error: %v", err)
+	}
+
+	if result.Known != "ok" {
+		t.Fatalf("expected Known=ok, got %q", result.Known)
+	}
+	if result.Extra == nil || len(result.Extra) != 2 {
+		t.Fatalf("expected Extra to contain 2 items, got %v", result.Extra)
+	}
+	if result.Extra["extra1"] != "v1" {
+		t.Fatalf("expected extra1=v1, got %v", result.Extra["extra1"])
+	}
+}
+
 func TestDecoder_DecodeNilOption(t *testing.T) {
 	t.Parallel()