[proposal] Auto magically inject services

service.go

@@ -2,11 +2,13 @@ package do
 
 import (
 	"fmt"
+	"reflect"
 )
 
 type Service[T any] interface {
 	getName() string
 	getInstance(*Injector) (T, error)
+	// getInstanceAny(*Injector) (any, error)
 	healthcheck() error
 	shutdown() error
 	clone() any
@@ -20,9 +22,21 @@ type shutdownableService interface {
 	shutdown() error
 }
 
+type anyService interface {
+	getInstanceAny(*Injector) (any, error)
+}
+
+func getServiceNameFromStructField(field *reflect.StructField) string {
+	t := reflect.New(field.Type).Elem().Interface()
+	return getServiceNameFromValue(t)
+}
+
 func generateServiceName[T any]() string {
 	var t T
+	return getServiceNameFromValue(t)
+}
 
+func getServiceNameFromValue[T any](t T) string {
 	// struct
 	name := fmt.Sprintf("%T", t)
 	if name != "<nil>" {

service_eager.go

@@ -22,6 +22,10 @@ func (s *ServiceEager[T]) getInstance(i *Injector) (T, error) {
 	return s.instance, nil
 }
 
+func (s *ServiceEager[T]) getInstanceAny(i *Injector) (any, error) {
+	return s.getInstance(i)
+}
+
 func (s *ServiceEager[T]) healthcheck() error {
 	instance, ok := any(s.instance).(Healthcheckable)
 	if ok {

service_lazy.go

@@ -45,6 +45,11 @@ func (s *ServiceLazy[T]) getInstance(i *Injector) (T, error) {
 	return s.instance, nil
 }
 
+//nolint:unused
+func (s *ServiceLazy[T]) getInstanceAny(i *Injector) (any, error) {
+	return s.getInstance(i)
+}
+
 //nolint:unused
 func (s *ServiceLazy[T]) build(i *Injector) (err error) {
 	defer func() {

tag.go

@@ -0,0 +1,93 @@
+package do
+
+import (
+	"fmt"
+	"reflect"
+	"unsafe"
+)
+
+const tagName = "do"
+
+func InjectTag[T any](i *Injector, service T) (T, error) {
+	_i := getInjectorOrDefault(i)
+	return populateServiceByTags(_i, service)
+}
+
+func MustInjectTag[T any](i *Injector, service T) T {
+	v, err := InjectTag(i, service)
+	must(err)
+	return v
+}
+
+func TagProvider[T any](t T) Provider[T] {
+	return func(i *Injector) (T, error) {
+		return InjectTag(i, t)
+	}
+}
+
+func populateServiceByTags[T any](i *Injector, service T) (T, error) {
+	// get the underlying value
+	value := reflect.ValueOf(service)
+
+	// return error if provided service is not a pointer
+	if value.Kind() != reflect.Ptr {
+		return empty[T](), fmt.Errorf("DI: expected a pointer")
+	}
+
+	// look for the underlying value type
+	for value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+
+	// check if underlying value is a struct
+	kind := value.Kind()
+	if kind != reflect.Struct {
+		return service, nil
+	}
+
+	tYpe := value.Type()
+
+	// for each field, we try to inject value
+	for j := 0; j < tYpe.NumField(); j++ {
+		field := tYpe.Field(j)
+
+		tag, ok := field.Tag.Lookup(tagName)
+		if !ok {
+			continue
+		}
+
+		serviceName := tag
+		if len(tag) == 0 {
+			serviceName = getServiceNameFromStructField(&field)
+		}
+
+		// fmt.Println("lookup service:", serviceName)
+
+		serviceAny, ok := i.get(serviceName)
+		if !ok {
+			return empty[T](), i.serviceNotFound(serviceName)
+		}
+
+		service, ok := serviceAny.(anyService)
+		if !ok {
+			return empty[T](), i.serviceNotFound(serviceName)
+		}
+
+		instance, err := service.getInstanceAny(i)
+		if err != nil {
+			return empty[T](), err
+		}
+
+		newValue := reflect.ValueOf(instance)
+		if newValue.Type() != field.Type {
+			return empty[T](), fmt.Errorf("DI: type mismatch. Expected '%s', got '%s'", newValue.Type().String(), field.Type.String())
+		}
+
+		// https://stackoverflow.com/questions/42664837/how-to-access-unexported-struct-fields
+		reflect.NewAt(field.Type, unsafe.Pointer(value.Field(j).UnsafeAddr())).
+			Elem().
+			Set(newValue)
+	}
+
+	return service, nil
+}

tag_test.go

@@ -0,0 +1,57 @@
+package do
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTag(t *testing.T) {
+	is := assert.New(t)
+
+	type foobar string
+
+	type hello struct {
+		world string
+	}
+
+	type test struct {
+		foobar1 string `do:"baz"`
+		foobar2 foobar `do:""`
+		foobar3 *hello `do:""`
+		foobar4 *hello `do` //nolint:govet
+		foobar5 string
+	}
+
+	injector := New()
+
+	ProvideNamedValue(injector, "baz", "foobar1")
+	ProvideValue[foobar](injector, "foobar2")
+	Provide(injector, func(i *Injector) (*hello, error) {
+		return &hello{"foobar3"}, nil
+	})
+
+	_, err := InjectTag(injector, test{})
+	is.EqualError(err, "DI: expected a pointer")
+
+	_, err = InjectTag(injector, 42)
+	is.EqualError(err, "DI: expected a pointer")
+
+	v, err := InjectTag(injector, &test{})
+	is.Nil(err)
+	is.Equal("foobar1", v.foobar1)
+	is.Equal(foobar("foobar2"), v.foobar2)
+	is.Equal("foobar3", v.foobar3.world)
+	is.Nil(v.foobar4)
+	is.Equal("", v.foobar5)
+
+	type wrongType struct {
+		foobar int `do:"baz"` //nolint:unused
+	}
+
+	_, err = InjectTag(injector, &wrongType{})
+	is.EqualError(err, "DI: type mismatch. Expected 'string', got 'int'")
+
+	_, err = TagProvider(&test{})(injector)
+	is.Nil(err)
+}