Metadata tracking works properly with embedded structs

mapstructure.go

diff --git a/mapstructure.go b/mapstructure.go
index 70da05b..253859f 100644
--- a/mapstructure.go
+++ b/mapstructure.go
@@ -87,6 +87,16 @@
 		return nil, errors.New("result must be addressable (a pointer)")
 	}
 
+	if config.Metadata != nil {
+		if config.Metadata.Keys == nil {
+			config.Metadata.Keys = make([]string, 0)
+		}
+
+		if config.Metadata.Unused == nil {
+			config.Metadata.Unused = make([]string, 0)
+		}
+	}
+
 	if config.TagName == "" {
 		config.TagName = "mapstructure"
 	}
@@ -327,34 +337,49 @@
 		dataValKeysUnused[dataValKey.Interface()] = struct{}{}
 	}
 
-	errors := make([]string, 0)
-	valType := val.Type()
-	for i := 0; i < valType.NumField(); i++ {
-		fieldType := valType.Field(i)
-		fieldName := fieldType.Name
+	// This slice will keep track of all the structs we'll be decoding.
+	// There can be more than one struct if there are embedded structs
+	// that are squashed.
+	structs := make([]reflect.Value, 1, 5)
+	structs[0] = val
 
-		if fieldType.Anonymous {
-			// We have an embedded field. We "squash" the fields down if
-			// specified in the tag.
-			squash := false
-			tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
-			for _, tag := range tagParts[1:] {
-				if tag == "squash" {
-					squash = true
-					break
+	// Compile the list of all the fields that we're going to be decoding
+	// from all the structs.
+	fields := make(map[*reflect.StructField]reflect.Value)
+	for len(structs) > 0 {
+		structVal := structs[0]
+		structs = structs[1:]
+
+		structType := structVal.Type()
+		for i := 0; i < structType.NumField(); i++ {
+			fieldType := structType.Field(i)
+
+			if fieldType.Anonymous {
+				// We have an embedded field. We "squash" the fields down
+				// if specified in the tag.
+				squash := false
+				tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
+				for _, tag := range tagParts[1:] {
+					if tag == "squash" {
+						squash = true
+						break
+					}
+				}
+
+				if squash {
+					structs = append(structs, val.FieldByName(fieldType.Name))
+					continue
 				}
 			}
 
-			if squash {
-				inner := val.FieldByName(fieldName)
-				err := d.decodeStruct(name, data, inner)
-				if err != nil {
-					errors = appendErrors(errors, err)
-				}
-
-				continue
-			}
+			// Normal struct field, store it away
+			fields[&fieldType] = structVal.Field(i)
 		}
+	}
+
+	errors := make([]string, 0)
+	for fieldType, field := range fields {
+		fieldName := fieldType.Name
 
 		tagValue := fieldType.Tag.Get(d.config.TagName)
 		if tagValue != "" {
@@ -386,7 +411,6 @@
 		// Delete the key we're using from the unused map so we stop tracking
 		delete(dataValKeysUnused, rawMapKey.Interface())
 
-		field := val.Field(i)
 		if !field.IsValid() {
 			// This should never happen
 			panic("field is not valid")

mapstructure_test.go

diff --git a/mapstructure_test.go b/mapstructure_test.go
index 12e31c2..5535f8e 100644
--- a/mapstructure_test.go
+++ b/mapstructure_test.go
@@ -471,6 +471,42 @@
 	}
 }
 
+func TestMetadata_Embedded(t *testing.T) {
+	t.Parallel()
+
+	input := map[string]interface{}{
+		"vstring": "foo",
+		"vunique": "bar",
+	}
+
+	var md Metadata
+	var result EmbeddedSquash
+	config := &DecoderConfig{
+		Metadata: &md,
+		Result:   &result,
+	}
+
+	decoder, err := NewDecoder(config)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	err = decoder.Decode(input)
+	if err != nil {
+		t.Fatalf("err: %s", err.Error())
+	}
+
+	expectedKeys := []string{"Vunique", "Vstring"}
+	if !reflect.DeepEqual(md.Keys, expectedKeys) {
+		t.Fatalf("bad keys: %#v", md.Keys)
+	}
+
+	expectedUnused := []string{}
+	if !reflect.DeepEqual(md.Unused, expectedUnused) {
+		t.Fatalf("bad unused: %#v", md.Unused)
+	}
+}
+
 func TestNonPtrValue(t *testing.T) {
 	t.Parallel()