Dynamically call method on interface{} regardless of receiver type

I'm working on a templating system written in Go, which means it requires liberal use of the reflect package. In this specific circumstance I need to be able to dynamically call a method on an interface{}. The oddity is that my reflection logic works fine as long as my data is of a known type, but not if the data is of type interface{}.

The the following example you can see that the logic in main() and Pass() is identical. The only difference is whether the data is a known type or a known type inside an interface{}

Go Play: http://play.golang.org/p/FTP3wgc0sZ

package main

import (
	"fmt"
	"reflect"
)

type Test struct {
	Start string
}

func (t *Test) Finish() string {
	return t.Start + "finish"
}

func Pass(i interface{}) {
	_, ok := reflect.TypeOf(&i).MethodByName("Finish")
	if ok {
		fmt.Println(reflect.ValueOf(&i).MethodByName("Finish").Call([]reflect.Value{})[0])
	} else {
		fmt.Println("Pass() fail")
	}
}

func main() {
	i := Test{Start: "start"}
	
	Pass(i)
	_, ok := reflect.TypeOf(&i).MethodByName("Finish")
	if ok {
		fmt.Println(reflect.ValueOf(&i).MethodByName("Finish").Call([]reflect.Value{})[0])
	} else {
		fmt.Println("main() fail")
	}
}

Upon executing this code we get the following result

Pass() fail
startfinish

Which means that my methodology for dynamically calling a method works fine except in a scenario when my object is currently in an interface{}.

If instead I do not use a pointer receiver and pass i then it works as expected.

Go Play: http://play.golang.org/p/myM0UXVYzX

This leads me to believe that my problem is that I cannot access the address of i (&i) when it is an interface{}. I've scoured the reflect package and tested things such as reflect.Value.Addr() and reflect.PtrTo() but I could not get either to work the way I needed. My hunch is that it has something to do with the fact that an interface{} is by definition a reference object.

Thanks to @Jeremy Wall I believe I was able to solve my problem. The basic issue is calling a dynamically named method on an interface{}. There are 4 cases.

1. interface{} underlying data is value and receiver is value
2. interface{} underlying data is pointer and receiver is value
3. interface{} underlying data is value and receiver is pointer
4. interface{} underlying data is pointer and receiver is pointer

Using reflection we can determine the underling value of our interface. Then using further reflection we can generate the alternate data type to our current type. If the data passed in was a value we need to generate a pointer to it

value := reflect.ValueOf(data)
if value.Type().Kind() == reflect.Ptr {
	ptr = value
	value = ptr.Elem() // acquire value referenced by pointer
} else {
	ptr = reflect.New(reflect.TypeOf(i)) // create new pointer
	temp := ptr.Elem() // create variable to value of pointer
	temp.Set(value) // set value of variable to our passed in value
}

Now that we have both data types we can simply use each to check for an existing method

var finalMethod reflect.Value
method := value.MethodByName(methodName)
if method.IsValid() {
	finalMethod = method
}
// check for method on pointer
method = ptr.MethodByName(methodName)
if method.IsValid() {
	finalMethod = method
}

if (finalMethod.IsValid()) {
	return finalMethod.Call([]reflect.Value{})[0].String()
}

Therefore with this in mind we can effectively call any method, dynamically, whether declared as *receiver or receiver.

Full Proof of Concept: http://play.golang.org/p/AU-Km5VjZs

package main

import (
	"fmt"
	"reflect"
)

type Test struct {
	Start string
}

// value receiver
func (t Test) Finish() string {
	return t.Start + "finish"
}

// pointer receiver
func (t *Test) Another() string {
	return t.Start + "another"
}

func CallMethod(i interface{}, methodName string) interface{} {
	var ptr reflect.Value
	var value reflect.Value
	var finalMethod reflect.Value
	
	value = reflect.ValueOf(i)
	
	// if we start with a pointer, we need to get value pointed to
	// if we start with a value, we need to get a pointer to that value
	if value.Type().Kind() == reflect.Ptr {
		ptr = value
		value = ptr.Elem()
	} else {
		ptr = reflect.New(reflect.TypeOf(i))
		temp := ptr.Elem()
		temp.Set(value)
	}
	
	// check for method on value
	method := value.MethodByName(methodName)
	if method.IsValid() {
		finalMethod = method
	}
	// check for method on pointer
	method = ptr.MethodByName(methodName)
	if method.IsValid() {
		finalMethod = method
	}
	
	if (finalMethod.IsValid()) {
		return finalMethod.Call([]reflect.Value{})[0].Interface()
	}
	
	// return or panic, method not found of either type
	return ""
}

func main() {
	i := Test{Start: "start"}
	j := Test{Start: "start2"}
	
	fmt.Println(CallMethod(i, "Finish"))
	fmt.Println(CallMethod(&i, "Finish"))
	fmt.Println(CallMethod(i, "Another"))
	fmt.Println(CallMethod(&i, "Another"))
	fmt.Println(CallMethod(j, "Finish"))
	fmt.Println(CallMethod(&j, "Finish"))
	fmt.Println(CallMethod(j, "Another"))
	fmt.Println(CallMethod(&j, "Another"))
}

In your example you don't call pass with something that supports the Finish method since Finish is only defined on pointers to Test structs. MethodByName is doing exactly what it should in that case. *Test != Test they are two different types completely. No amount of reflection will turn a Test into a *Test. And really it shouldn't either. You can use the PtrTo function to find out if the Finish method is defined on the pointer type but that won't help you get a pointer to the actual value.

Calling Pass with a pointer works: http://play.golang.org/p/fICI3cqT4t

This is a good example of golang to implement similar functionality:

package main

import "fmt"

type Parent struct {
    Attr1 string
}

type Parenter interface {
    GetParent() Parent
}

type Child struct {
    Parent //embed
    Attr   string
}

func (c Child) GetParent() Parent {
    return c.Parent
}

func setf(p Parenter) {
    fmt.Println(p)
}

func main() {
    var ch Child
    ch.Attr = "1"
    ch.Attr1 = "2"

    setf(ch)
}

code from : https://groups.google.com/d/msg/golang-nuts/8lK0WsGqQ-0/HJgsYW_HCDoJ