unused: handle reflect's Method and MethodByName

[dominikh]

Input:

package pkg

import "reflect"

type t struct{}

func (t) foo() {}

func Fn() {
	var v t
	reflect.ValueOf(v).MethodByName("foo")
}

Current output:

foo.go:7:10: func t.foo is unused (U1000)

Desired output:
None.

Solution:

There isn't a perfect way to solve this because we can't accurately track the flow of reflect.Value through all code. A good approximation would be matching the exact code pattern from the example. This would reduce a lot of false positives without requiring much new code. The next step up would be tracking values created from reflect.ValueOf inside a single function. This would catch some more false positives and only increase the complexity of the algorithm a bit. The second step up would be inter-procedural analysis, which we're not likely to be doing.

We can also track the arguments to Method and MethodByName at different levels. We will likely restrict ourselves to trivially known constants, and fall back to marking all methods as used if the argument is dynamic. Method needs special care because we have to use the same order of methods as the reflect package. In reality, however, most (all?) uses of Method will be dynamic, anyway, iterating over all methods.