golang: Unmarshal dynamic YAML annonation

I want to dynamically change the annotation of a struct and use yaml.Unmarshal like below:

package main

import (
    "fmt"
    "reflect"

    "gopkg.in/yaml.v3"
)

type User struct {
    Name string `yaml:"dummy"`
}

func (u *User) UnmarshalYAML(node *yaml.Node) error {
    value := reflect.ValueOf(*u)
    t := value.Type()
    fields := make([]reflect.StructField, 0)

    for i := 0; i < t.NumField(); i++ {
        fields = append(fields, t.Field(i))

        if t.Field(i).Name == "Name" {
            fields[i].Tag = `yaml:"name"` // Dynamic annotation
        }
    }

    newType := reflect.StructOf(fields)
    newValue := value.Convert(newType)

    err := node.Decode(newValue.Interface()) // Cause error because it's not pointer
    return err
}

var dat string = `name: abc`

func main() {
    out := User{}
    yaml.Unmarshal([]byte(dat), &out)
    fmt.Printf("%+v\n", out)
}

It causes errors like panic: reflect: reflect.Value.Set using unaddressable value [recovered] and I think it's because node.Decode is not used with a pointer. So how to create the pointer of the new type?

Here goes the updated demo that works:

package main

import (
	"fmt"
	"reflect"
	"unsafe"

	"gopkg.in/yaml.v3"
)

type User struct {
	Name string `yaml:"dummy"`
}

func (u *User) UnmarshalYAML(node *yaml.Node) error {
	t := reflect.TypeOf(*u)
	fields := make([]reflect.StructField, 0)

	for i := 0; i < t.NumField(); i++ {
		fields = append(fields, t.Field(i))

		if t.Field(i).Name == "Name" {
			fields[i].Tag = `yaml:"name"` // Dynamic annotation
		}
	}

	newType := reflect.StructOf(fields)
	newValue := reflect.NewAt(newType, unsafe.Pointer(u)).Elem()

	err := node.Decode(newValue.Addr().Interface())
	return err
}

var dat string = `name: abc`

func main() {
	out := User{}
	yaml.Unmarshal([]byte(dat), &out)
	fmt.Printf("%+v\n", out)
}

Two key changes:

1. Replace newValue.Interface() with newValue.Addr().Interface(). (See this example: https://pkg.go.dev/reflect#example-StructOf)

2. Replace newValue := value.Convert(newType) with newValue := reflect.NewAt(newType, unsafe.Pointer(u)).Elem().

   We do this because value in value := reflect.ValueOf(*u) is unaddressable (You can verify it with fmt.Printf("%v", value.Addr()). It panics with message panic: reflect.Value.Addr of unaddressable value).