Cache reflect.MethodByName

The isolated benchmark for the function is obviously much faster:

```bash
name                old time/op    new time/op    delta
GetMethodByName-10    1.21µs ± 7%    0.23µs ± 5%   -81.42%  (p=0.029 n=4+4)

name                old alloc/op   new alloc/op   delta
GetMethodByName-10      680B ± 0%        0B       -100.00%  (p=0.029 n=4+4)

name                old allocs/op  new allocs/op  delta
GetMethodByName-10      20.0 ± 0%       0.0       -100.00%  (p=0.029 n=4+4)
```

But more pleasing is the overall performance looking at the site benchmarks:

```bash
name                                      old time/op    new time/op    delta
SiteNew/Regular_Bundle_with_image-10        6.25ms ± 2%    6.10ms ± 2%     ~     (p=0.057 n=4+4)
SiteNew/Regular_Bundle_with_JSON_file-10    6.30ms ± 2%    5.66ms ±11%     ~     (p=0.057 n=4+4)
SiteNew/Regular_Tags_and_categories-10      22.2ms ± 2%    17.4ms ± 1%  -21.88%  (p=0.029 n=4+4)
SiteNew/Regular_Canonify_URLs-10             108ms ± 0%     107ms ± 0%   -1.20%  (p=0.029 n=4+4)
SiteNew/Regular_Deep_content_tree-10        36.1ms ± 1%    33.8ms ± 1%   -6.44%  (p=0.029 n=4+4)
SiteNew/Regular_TOML_front_matter-10        24.9ms ± 1%    22.6ms ± 1%   -9.30%  (p=0.029 n=4+4)
SiteNew/Regular_Many_HTML_templates-10      17.9ms ± 1%    16.7ms ± 1%   -6.43%  (p=0.029 n=4+4)
SiteNew/Regular_Page_collections-10         23.3ms ± 1%    22.0ms ± 0%   -5.58%  (p=0.029 n=4+4)
SiteNew/Regular_List_terms-10               8.00ms ± 1%    7.63ms ± 0%   -4.62%  (p=0.029 n=4+4)

name                                      old alloc/op   new alloc/op   delta
SiteNew/Regular_Bundle_with_image-10        2.10MB ± 0%    2.07MB ± 0%   -1.46%  (p=0.029 n=4+4)
SiteNew/Regular_Bundle_with_JSON_file-10    1.88MB ± 0%    1.85MB ± 0%   -1.76%  (p=0.029 n=4+4)
SiteNew/Regular_Tags_and_categories-10      13.5MB ± 0%    11.6MB ± 0%  -13.99%  (p=0.029 n=4+4)
SiteNew/Regular_Canonify_URLs-10            96.1MB ± 0%    95.8MB ± 0%   -0.40%  (p=0.029 n=4+4)
SiteNew/Regular_Deep_content_tree-10        28.4MB ± 0%    27.3MB ± 0%   -3.83%  (p=0.029 n=4+4)
SiteNew/Regular_TOML_front_matter-10        16.9MB ± 0%    15.1MB ± 0%  -10.58%  (p=0.029 n=4+4)
SiteNew/Regular_Many_HTML_templates-10      8.98MB ± 0%    8.44MB ± 0%   -6.04%  (p=0.029 n=4+4)
SiteNew/Regular_Page_collections-10         17.1MB ± 0%    16.5MB ± 0%   -3.91%  (p=0.029 n=4+4)
SiteNew/Regular_List_terms-10               3.92MB ± 0%    3.72MB ± 0%   -5.03%  (p=0.029 n=4+4)

name                                      old allocs/op  new allocs/op  delta
SiteNew/Regular_Bundle_with_image-10         25.8k ± 0%     24.9k ± 0%   -3.49%  (p=0.029 n=4+4)
SiteNew/Regular_Bundle_with_JSON_file-10     25.8k ± 0%     24.9k ± 0%   -3.49%  (p=0.029 n=4+4)
SiteNew/Regular_Tags_and_categories-10        288k ± 0%      233k ± 0%  -18.90%  (p=0.029 n=4+4)
SiteNew/Regular_Canonify_URLs-10              375k ± 0%      364k ± 0%   -2.80%  (p=0.029 n=4+4)
SiteNew/Regular_Deep_content_tree-10          314k ± 0%      283k ± 0%   -9.77%  (p=0.029 n=4+4)
SiteNew/Regular_TOML_front_matter-10          302k ± 0%      252k ± 0%  -16.55%  (p=0.029 n=4+4)
SiteNew/Regular_Many_HTML_templates-10        133k ± 0%      117k ± 0%  -11.81%  (p=0.029 n=4+4)
SiteNew/Regular_Page_collections-10           202k ± 0%      183k ± 0%   -9.55%  (p=0.029 n=4+4)
SiteNew/Regular_List_terms-10                55.6k ± 0%     49.8k ± 0%  -10.40%  (p=0.029 n=4+4)
```

Thanks to @quasilyte for the suggestion.

Fixes 9386

2 files changed, 97 insertions, 0 deletions

diff --git a/common/hreflect/helpers.go b/common/hreflect/helpers.go
index beab182bb..7087a9677 100644
--- a/common/hreflect/helpers.go
+++ b/common/hreflect/helpers.go
@@ -19,6 +19,7 @@ package hreflect
 import (
 	"context"
 	"reflect"
+	"sync"
 
 	"github.com/gohugoio/hugo/common/types"
 )
@@ -115,6 +116,58 @@ func IsTruthfulValue(val reflect.Value) (truth bool) {
 	return
 }
 
+type methodKey struct {
+	typ  reflect.Type
+	name string
+}
+
+type methods struct {
+	sync.RWMutex
+	cache map[methodKey]int
+}
+
+var methodCache = &methods{cache: make(map[methodKey]int)}
+
+// GetMethodByName is the samve as reflect.Value.MethodByName, but it caches the
+// type lookup.
+func GetMethodByName(v reflect.Value, name string) reflect.Value {
+	index := GetMethodIndexByName(v.Type(), name)
+
+	if index == -1 {
+		return reflect.Value{}
+	}
+
+	return v.Method(index)
+}
+
+// GetMethodIndexByName returns the index of the method with the given name, or
+// -1 if no such method exists.
+func GetMethodIndexByName(tp reflect.Type, name string) int {
+	k := methodKey{tp, name}
+	methodCache.RLock()
+	index, found := methodCache.cache[k]
+	methodCache.RUnlock()
+	if found {
+		return index
+	}
+
+	methodCache.Lock()
+	defer methodCache.Unlock()
+
+	m, ok := tp.MethodByName(name)
+	index = m.Index
+	if !ok {
+		index = -1
+	}
+	methodCache.cache[k] = index
+
+	if !ok {
+		return -1
+	}
+
+	return m.Index
+}
+
 // Based on: https://github.com/golang/go/blob/178a2c42254166cffed1b25fb1d3c7a5727cada6/src/text/template/exec.go#L931
 func indirectInterface(v reflect.Value) reflect.Value {
 	if v.Kind() != reflect.Interface {
diff --git a/common/hreflect/helpers_test.go b/common/hreflect/helpers_test.go
index 480ccb27a..d16b9b9b3 100644
--- a/common/hreflect/helpers_test.go
+++ b/common/hreflect/helpers_test.go
@@ -30,6 +30,16 @@ func TestIsTruthful(t *testing.T) {
 	c.Assert(IsTruthful(time.Time{}), qt.Equals, false)
 }
 
+func TestGetMethodByName(t *testing.T) {
+	c := qt.New(t)
+	v := reflect.ValueOf(&testStruct{})
+	tp := v.Type()
+
+	c.Assert(GetMethodIndexByName(tp, "Method1"), qt.Equals, 0)
+	c.Assert(GetMethodIndexByName(tp, "Method3"), qt.Equals, 2)
+	c.Assert(GetMethodIndexByName(tp, "Foo"), qt.Equals, -1)
+}
+
 func BenchmarkIsTruthFul(b *testing.B) {
 	v := reflect.ValueOf("Hugo")
 
@@ -40,3 +50,37 @@ func BenchmarkIsTruthFul(b *testing.B) {
 		}
 	}
 }
+
+type testStruct struct{}
+
+func (t *testStruct) Method1() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method2() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method3() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method4() string {
+	return "Hugo"
+}
+
+func (t *testStruct) Method5() string {
+	return "Hugo"
+}
+
+func BenchmarkGetMethodByName(b *testing.B) {
+	v := reflect.ValueOf(&testStruct{})
+	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, method := range methods {
+			_ = GetMethodByName(v, method)
+		}
+	}
+}