Mark meta keys as decoded when using Unmarshaler interface (#426)

Keys were marked as "Undecoded" in the meta when using UnmarshalTOML
from the Unmarshaler interface. Unlike Primitive, I don't think this
makes sense as UnmarshalTOML() explicitly "decodes" the value.

Also mark all values below the table or array, and assume the parent
UnmarshalTOML() handled this correctly.

Fixes #425

Author: mvo5

decode.go

@@ -196,6 +196,19 @@ func (md *MetaData) PrimitiveDecode(primValue Primitive, v any) error {
 	return md.unify(primValue.undecoded, rvalue(v))
 }
 
+// markDecodedRecursive is a helper to mark any key under the given tmap as
+// decoded, recursing as needed
+func markDecodedRecursive(md *MetaData, tmap map[string]any) {
+	for key := range tmap {
+		md.decoded[md.context.add(key).String()] = struct{}{}
+		if tmap, ok := tmap[key].(map[string]any); ok {
+			md.context = append(md.context, key)
+			markDecodedRecursive(md, tmap)
+			md.context = md.context[0 : len(md.context)-1]
+		}
+	}
+}
+
 // unify performs a sort of type unification based on the structure of `rv`,
 // which is the client representation.
 //
@@ -222,6 +235,16 @@ func (md *MetaData) unify(data any, rv reflect.Value) error {
 		if err != nil {
 			return md.parseErr(err)
 		}
+		// Assume the Unmarshaler decoded everything, so mark all keys under
+		// this table as decoded.
+		if tmap, ok := data.(map[string]any); ok {
+			markDecodedRecursive(md, tmap)
+		}
+		if aot, ok := data.([]map[string]any); ok {
+			for _, tmap := range aot {
+				markDecodedRecursive(md, tmap)
+			}
+		}
 		return nil
 	}
 	if v, ok := rvi.(encoding.TextUnmarshaler); ok {

decode_test.go

@@ -1018,7 +1018,7 @@ func TestCustomEncode(t *testing.T) {
 // Test for #341
 func TestCustomDecode(t *testing.T) {
 	var outer Outer
-	_, err := Decode(`
+	meta, err := Decode(`
 		Int = 10
 		Enum = "OTHER_VALUE"
 		Slice = ["text1", "text2"]
@@ -1036,6 +1036,9 @@ func TestCustomDecode(t *testing.T) {
 	if fmt.Sprint(outer.Slice.value) != fmt.Sprint([]string{"text1", "text2"}) {
 		t.Errorf("\nhave:\n%v\nwant:\n%v\n", outer.Slice.value, []string{"text1", "text2"})
 	}
+	if len(meta.Undecoded()) > 0 {
+		t.Errorf("\ncustom decode leaves unencoded fields: %v\n", meta.Undecoded())
+	}
 }
 
 // TODO: this should be improved for v2:
@@ -1144,3 +1147,45 @@ func BenchmarkKey(b *testing.B) {
 		k.String()
 	}
 }
+
+type UnmarshalTOMLNoop struct {
+}
+
+func (cs *UnmarshalTOMLNoop) UnmarshalTOML(data any) error {
+	return nil
+}
+
+func TestDecodeCustomStructMarkedDecoded(t *testing.T) {
+	var s struct {
+		Str UnmarshalTOMLNoop `toml:"str"`
+		Int UnmarshalTOMLNoop `toml:"int"`
+		Arr UnmarshalTOMLNoop `toml:"arr"`
+		Tbl UnmarshalTOMLNoop `toml:"tbl"`
+		Aot UnmarshalTOMLNoop `toml:"aot"`
+	}
+	meta, err := Decode(`
+		str = "bar"
+		int   = 1
+		arr = [2]
+
+		[tbl]
+		b = 3
+		inline = {c = 4}
+
+		[[aot]]
+		a = 1
+		[[aot]]
+		a = 1
+	`, &s)
+	if err != nil {
+		t.Fatalf("Decode failed: %s", err)
+	}
+
+	// Note that even though the custom unmarshaller did not decode all fields
+	// as far as the metadata is concerned they are handled. It is the job of
+	// the unmarshaller to ensure this or we would need a more powerful
+	// interface like UnmarshalTOML(data any, md *MetaData)
+	if len(meta.Undecoded()) > 0 {
+		t.Errorf("\ncustom decode leaves undecoded fields: %v\n", meta.Undecoded())
+	}
+}