feat: support recursive injection of provider parameters

This allows provider functions to accept parameters that are injected by other
bindings or binding providers, eg. call the provider function with the root CLI
struct (which is automatically bound by Kong):

  kong.BindToProvider(func(cli *CLI) (*Injected, error) { ... })

callbacks.go

@@ -6,7 +6,10 @@ import (
 	"strings"
 )
 
-type bindings map[reflect.Type]func() (reflect.Value, error)
+// A map of type to function that returns a value of that type.
+//
+// The function should have the signature func(...) (T, error). Arguments are recursively resolved.
+type bindings map[reflect.Type]any
 
 func (b bindings) String() string {
 	out := []string{}
@@ -19,32 +22,23 @@ func (b bindings) String() string {
 func (b bindings) add(values ...interface{}) bindings {
 	for _, v := range values {
 		v := v
-		b[reflect.TypeOf(v)] = func() (reflect.Value, error) { return reflect.ValueOf(v), nil }
+		b[reflect.TypeOf(v)] = func() (any, error) { return v, nil }
 	}
 	return b
 }
 
 func (b bindings) addTo(impl, iface interface{}) {
-	valueOf := reflect.ValueOf(impl)
-	b[reflect.TypeOf(iface).Elem()] = func() (reflect.Value, error) { return valueOf, nil }
+	b[reflect.TypeOf(iface).Elem()] = func() (any, error) { return impl, nil }
 }
 
 func (b bindings) addProvider(provider interface{}) error {
 	pv := reflect.ValueOf(provider)
 	t := pv.Type()
-	if t.Kind() != reflect.Func || t.NumIn() != 0 || t.NumOut() != 2 || t.Out(1) != reflect.TypeOf((*error)(nil)).Elem() {
-		return fmt.Errorf("%T must be a function with the signature func()(T, error)", provider)
+	if t.Kind() != reflect.Func || t.NumOut() != 2 || t.Out(1) != reflect.TypeOf((*error)(nil)).Elem() {
+		return fmt.Errorf("%T must be a function with the signature func(...)(T, error)", provider)
 	}
 	rt := pv.Type().Out(0)
-	b[rt] = func() (reflect.Value, error) {
-		out := pv.Call(nil)
-		errv := out[1]
-		var err error
-		if !errv.IsNil() {
-			err = errv.Interface().(error) //nolint
-		}
-		return out[0], err
-	}
+	b[rt] = provider
 	return nil
 }
 
@@ -101,15 +95,19 @@ func callAnyFunction(f reflect.Value, bindings bindings) (out []any, err error)
 	t := f.Type()
 	for i := 0; i < t.NumIn(); i++ {
 		pt := t.In(i)
-		if argf, ok := bindings[pt]; ok {
-			argv, err := argf()
-			if err != nil {
-				return nil, err
-			}
-			in = append(in, argv)
-		} else {
+		argf, ok := bindings[pt]
+		if !ok {
 			return nil, fmt.Errorf("couldn't find binding of type %s for parameter %d of %s(), use kong.Bind(%s)", pt, i, t, pt)
 		}
+		// Recursively resolve binding functions.
+		argv, err := callAnyFunction(reflect.ValueOf(argf), bindings)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", pt, err)
+		}
+		if ferrv := reflect.ValueOf(argv[len(argv)-1]); ferrv.IsValid() && !ferrv.IsNil() {
+			return nil, ferrv.Interface().(error) //nolint:forcetypeassert
+		}
+		in = append(in, reflect.ValueOf(argv[0]))
 	}
 	outv := f.Call(in)
 	out = make([]any, len(outv))