v3: yaml.Unmarshaler.UnmarshalYAML does not get called on inlined maps

[lithdew]

Having the receiver of UnmarshalYAML be a pointer receiver does not seem to change the fact that "this does not get called" does not get printed.

package main

import (
	"fmt"
	"gopkg.in/yaml.v3"
)

type Field struct {
	Properties Properties `yaml:"-,inline"`
}

var _ yaml.Unmarshaler = Properties{}

type Properties map[string]string

func (p Properties) UnmarshalYAML(value *yaml.Node) error {
	fmt.Println("this does not get called")
	return value.Decode(p)
}

func main() {
	input := `a: 1
b: 2
c: 3`

	var field Field
	if err := yaml.Unmarshal([]byte(input), &field); err != nil {
		panic(err)
	}

	fmt.Println(field)
}

[sustrik]

I wonder whether this is a more generic problem about structs without custom (un)marshaller not calling custome (un)marshaller on the struct members:

import (
    "fmt"
    "log"
    "gopkg.in/yaml.v3"
)

type Outer struct {
  Inner Inner
}

type Inner struct {}

func (i *Inner) MarshalYAML() (interface{}, error) {
	return "foo", nil
}

func main() {
    t := Outer{}
    data, err := yaml.Marshal(t)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s\n", data)
}

Expected: "inner: foo" Got: "inner: {}"

[sustrik]

After a bit of debugging: In my case the problem can be fixed by making Inner a pointer:

type Outer struct {
  Inner *Inner
}

The problem is caused by marshal() function trying to convert the value to Marshaller interface, but of course, given that the structure is embedded, rather than referred to by a pointer, the conversion fails. (see

yaml/encode.go

Line 125 in 7649d45

case Marshaler:

)

I wonder whether a special case can be added, that makes pointer to the structure and tries to convert that to Marshaller.

[sustrik]

Tentative PR: #743

[aathan]

#979