Will this cause a memory leak in Go?

In the following code I have two struct types: ObjectDefinition and fieldDefinition both in the same package. fieldDefinition structs should only be created via a method on ObjectDefinition to prevent orphaned fields (the system in question will be an extensible CRM).

The AddReferenceField method should create a new fieldDefintion, set some variables on it, add it to the parent struct's slice of *fieldDefinition and then also return the pointer to it to allow the programmer to easily manipulate the field further without having to find and retrieve it from the slice.

type ObjectDefinition struct {
	myId        id.ID
	orgId       id.ID
	apiName     string
	label       string
	pluralLabel string
	description string
	helpText    string
	fields      map[id.ID]*fieldDefinition
	newFields   []*fieldDefinition
	systemFields
}

/*
AddReferenceField adds a reference type field to the list of uncommitted fields
with the given parameters and returns a pointer to it. This function will return
a nil pointer and an error if any of the given parameters were invalid.
*/
func (o *ObjectDefinition) AddReferenceField(name, label string, refObj id.ID, reparentable bool, delCon deleteConstraint) (*fieldDefinition, error) {

	//TODO - investigate this as a possible source of memory leakage. Creating a pointer, adding that pointer to a slice, then returning the same pointer.
	nrf := new(fieldDefinition)
	nrf.fieldType = FT_REFERENCE

	if err := nrf.SetName(name); err != nil {
		return nil, err
	}

	if err := nrf.SetLabel(label); err != nil {
		return nil, err
	}

	if err := nrf.SetReferenceObjectId(refObj); err != nil {
		return nil, err
	}

	if err := nrf.SetReparentable(reparentable); err != nil {
		return nil, err
	}

	if err := nrf.SetDeleteConstraint(delCon); err != nil {
		return nil, err
	}

	o.newFields = append(o.newFields, nrf)
	return nrf, nil

}

I haven't included the full fieldDefinition code because it's not really relevant and it's quite bulky, but an example of this being used from the main program loop would be:

var od ObjectDefinition
newId := id.Generate()
newField, newFieldErr := od.AddReferenceField("example", "Example", newId, false, DC_SETNULL)

newField.SetSomethingElse(true)

So now newField is a pointer to fieldDefinition, but the same pointer has been added to a slice on od. Is there a potential for memory leakage here?

Go is a garbage collected language. Echoing what people in the comments have said, this does not cause a memory leak. While od holds the pointer to the newly created fieldDefinition, that fieldDefinition will stay in the heap. When od goes out of scope and is destroyed, all the fieldDefinitions it's pointing to will also become eligible for garbage collection, provided that nothing live is holding a pointer to them.