feat(depinject): resolve interface types

depinject/container.go

@@ -3,18 +3,15 @@ package depinject
 import (
 	"bytes"
 	"fmt"
-	"reflect"
-
-	"github.com/pkg/errors"
-
 	"github.com/cosmos/cosmos-sdk/depinject/internal/graphviz"
+	"github.com/pkg/errors"
+	"reflect"
 )
 
 type container struct {
 	*debugConfig
 
-	resolvers      map[reflect.Type]resolver
-	keyedResolvers map[string]resolver
+	resolvers map[reflect.Type]resolver
 
 	moduleKeys map[string]*moduleKey
 
@@ -30,12 +27,11 @@ type resolveFrame struct {
 
 func newContainer(cfg *debugConfig) *container {
 	return &container{
-		debugConfig:    cfg,
-		resolvers:      map[reflect.Type]resolver{},
-		keyedResolvers: map[string]resolver{},
-		moduleKeys:     map[string]*moduleKey{},
-		callerStack:    nil,
-		callerMap:      map[Location]bool{},
+		debugConfig: cfg,
+		resolvers:   map[reflect.Type]resolver{},
+		moduleKeys:  map[string]*moduleKey{},
+		callerStack: nil,
+		callerMap:   map[Location]bool{},
 	}
 }
 
@@ -78,13 +74,8 @@ func (c *container) call(provider *ProviderDescriptor, moduleKey *moduleKey) ([]
 	return out, nil
 }
 
-func (c *container) getResolver(typ reflect.Type, key string) (resolver, error) {
-	if key != "" {
-		if vr, ok := c.keyedResolvers[key]; ok {
-			return vr, nil
-		}
-	}
-
+func (c *container) getResolver(typ reflect.Type) (resolver, error) {
+	c.logf("Resolving %v", typ)
 	if vr, ok := c.resolvers[typ]; ok {
 		return vr, nil
 	}
@@ -130,7 +121,27 @@ func (c *container) getResolver(typ reflect.Type, key string) (resolver, error)
 		c.resolvers[mapType] = &mapOfOnePerModuleResolver{r}
 	}
 
-	return c.resolvers[typ], nil
+	res := c.resolvers[typ]
+
+	if res == nil && typ.Kind() == reflect.Interface {
+		var found bool
+		for k, r := range c.resolvers {
+			if k.Kind() != reflect.Interface && k.Implements(typ) {
+				c.logf("Found candidate resolver, implicitly binding interface %v to implementing type %v.", typ, k)
+				if found {
+					return nil, &ErrMultipleImplicitInterfaceBindings{Interface: typ}
+				}
+				res = r
+				found = true
+			}
+		}
+
+		if found {
+			c.resolvers[typ] = res
+		}
+	}
+
+	return res, nil
 }
 
 var stringType = reflect.TypeOf("")
@@ -155,7 +166,7 @@ func (c *container) addNode(provider *ProviderDescriptor, key *moduleKey) (inter
 			return nil, fmt.Errorf("one-per-module type %v can't be used as an input parameter", typ)
 		}
 
-		vr, err := c.getResolver(typ, in.Key)
+		vr, err := c.getResolver(typ)
 		if err != nil {
 			return nil, err
 		}
@@ -197,7 +208,7 @@ func (c *container) addNode(provider *ProviderDescriptor, key *moduleKey) (inter
 				typ = typ.Elem()
 			}
 
-			vr, err := c.getResolver(typ, out.Key)
+			vr, err := c.getResolver(typ)
 			if err != nil {
 				return nil, err
 			}
@@ -219,10 +230,6 @@ func (c *container) addNode(provider *ProviderDescriptor, key *moduleKey) (inter
 					idxInValues: i,
 				}
 				c.resolvers[typ] = vr
-
-				if out.Key != "" {
-					c.keyedResolvers[out.Key] = vr
-				}
 			}
 
 			c.addGraphEdge(providerGraphNode, vr.typeGraphNode())
@@ -257,18 +264,13 @@ func (c *container) addNode(provider *ProviderDescriptor, key *moduleKey) (inter
 			}
 
 			typeGraphNode := c.typeGraphNode(typ)
-			mdr := &moduleDepResolver{
+			c.resolvers[typ] = &moduleDepResolver{
 				typ:         typ,
 				idxInValues: i,
 				node:        node,
 				valueMap:    map[*moduleKey]reflect.Value{},
 				graphNode:   typeGraphNode,
 			}
-			c.resolvers[typ] = mdr
-
-			if out.Key != "" {
-				c.keyedResolvers[out.Key] = mdr
-			}
 
 			c.addGraphEdge(providerGraphNode, typeGraphNode)
 		}
@@ -321,7 +323,7 @@ func (c *container) resolve(in ProviderInput, moduleKey *moduleKey, caller Locat
 		return reflect.ValueOf(OwnModuleKey{moduleKey}), nil
 	}
 
-	vr, err := c.getResolver(in.Type, in.Key)
+	vr, err := c.getResolver(in.Type)
 	if err != nil {
 		return reflect.Value{}, err
 	}

depinject/container_test.go

@@ -644,35 +644,37 @@ type AlsoDuck interface {
 }
 
 type Mallard struct{}
+type Canvasback struct{}
 
-func (duck Mallard) quack() {}
-
-type KeyedOutput struct {
-	depinject.Out
-	Duck Duck `key:"foo"`
-}
-
-type KeyedInput struct {
-	depinject.In
-	AlsoDuck AlsoDuck `key:"foo"`
-}
+func (duck Mallard) quack()    {}
+func (duck Canvasback) quack() {}
 
 type Pond struct {
 	Duck AlsoDuck
 }
 
-func TestKeyedInputOutput(t *testing.T) {
+func TestImplicitBindings(t *testing.T) {
 	var pond Pond
 
 	require.NoError(t,
 		depinject.Inject(
 			depinject.Provide(
-				func() KeyedOutput { return KeyedOutput{Duck: Mallard{}} },
-				func(in KeyedInput) Pond {
-					require.NotNil(t, in.AlsoDuck)
-					return Pond{Duck: in.AlsoDuck}
+				func() Mallard { return Mallard{} },
+				func(duck Duck) Pond {
+					require.NotNil(t, duck)
+					return Pond{Duck: duck}
 				}),
 			&pond))
 
 	require.NotNil(t, pond)
+
+	require.Error(t,
+		depinject.Inject(
+			depinject.Provide(
+				func() Mallard { return Mallard{} },
+				func() Canvasback { return Canvasback{} },
+				func(duck Duck) Pond {
+					return Pond{Duck: duck}
+				}),
+			&pond))
 }

depinject/errors.go

@@ -1,11 +1,21 @@
 package depinject
 
 import (
+	"fmt"
 	"reflect"
 
 	"github.com/pkg/errors"
 )
 
+type ErrMultipleImplicitInterfaceBindings struct {
+	Interface reflect.Type
+	Err       error
+}
+
+func (err ErrMultipleImplicitInterfaceBindings) Error() string {
+	return fmt.Sprintf("Multiple implementations found for interface %v", err.Interface)
+}
+
 func duplicateDefinitionError(typ reflect.Type, duplicateLoc Location, existingLoc string) error {
 	return errors.Errorf("duplicate provision of type %v by %s\n\talready provided by %s",
 		typ, duplicateLoc, existingLoc)

depinject/provider_desc.go

@@ -28,12 +28,10 @@ type ProviderDescriptor struct {
 type ProviderInput struct {
 	Type     reflect.Type
 	Optional bool
-	Key      string
 }
 
 type ProviderOutput struct {
 	Type reflect.Type
-	Key  string
 }
 
 func ExtractProviderDescriptor(provider interface{}) (ProviderDescriptor, error) {

depinject/provider_desc_test.go

@@ -24,16 +24,6 @@ type StructOut struct {
 	Y []byte
 }
 
-type KeyedIn struct {
-	depinject.In
-	X string `key:"theKey"`
-}
-
-type KeyedOut struct {
-	depinject.Out
-	X string `key:"theKey"`
-}
-
 func TestExtractProviderDescriptor(t *testing.T) {
 	var (
 		intType     = reflect.TypeOf(0)
@@ -97,20 +87,6 @@ func TestExtractProviderDescriptor(t *testing.T) {
 			nil,
 			true,
 		},
-		{
-			name:    "keyed input",
-			ctr:     func(_ KeyedIn) int { return 0 },
-			wantIn:  []depinject.ProviderInput{{Type: stringType, Key: "theKey"}},
-			wantOut: []depinject.ProviderOutput{{Type: intType}},
-			wantErr: false,
-		},
-		{
-			name:    "keyed output",
-			ctr:     func(s string) KeyedOut { return KeyedOut{X: "foo"} },
-			wantIn:  []depinject.ProviderInput{{Type: stringType}},
-			wantOut: []depinject.ProviderOutput{{Type: stringType, Key: "theKey"}},
-			wantErr: false,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

depinject/struct_args.go

@@ -120,16 +120,9 @@ func structArgsInTypes(typ reflect.Type) ([]ProviderInput, error) {
 			}
 		}
 
-		var key string
-		keyTag, keyFound := f.Tag.Lookup("key")
-		if keyFound {
-			key = keyTag
-		}
-
 		res = append(res, ProviderInput{
 			Type:     f.Type,
 			Optional: optional,
-			Key:      key,
 		})
 	}
 	return res, nil
@@ -158,15 +151,8 @@ func structArgsOutTypes(typ reflect.Type) []ProviderOutput {
 			continue
 		}
 
-		var key string
-		keyTag, keyFound := f.Tag.Lookup("key")
-		if keyFound {
-			key = keyTag
-		}
-
 		res = append(res, ProviderOutput{
 			Type: f.Type,
-			Key:  key,
 		})
 	}
 	return res

x/auth/module.go

@@ -211,7 +211,7 @@ func provideModuleBasic() runtime.AppModuleBasicWrapper {
 type authOutputs struct {
 	depinject.Out
 
-	AccountKeeper keeper.AccountKeeper `key:"cosmos.auth.v1.AccountKeeper"`
+	AccountKeeper keeper.AccountKeeper
 	Module        runtime.AppModuleWrapper
 }
 

x/bank/module.go

@@ -221,7 +221,7 @@ type bankInputs struct {
 	depinject.In
 
 	Config        *modulev1.Module
-	AccountKeeper types.AccountKeeper `key:"cosmos.auth.v1.AccountKeeper"`
+	AccountKeeper types.AccountKeeper
 	Cdc           codec.Codec
 	Subspace      paramtypes.Subspace
 	Key           *store.KVStoreKey
@@ -230,7 +230,7 @@ type bankInputs struct {
 type bankOutputs struct {
 	depinject.Out
 
-	BankKeeper keeper.Keeper `key:"cosmos.bank.v1.Keeper"`
+	BankKeeper keeper.BaseKeeper
 	Module     runtime.AppModuleWrapper
 }
 

x/feegrant/module/module.go

@@ -209,8 +209,8 @@ type feegrantInputs struct {
 
 	Key           *store.KVStoreKey
 	Cdc           codec.Codec
-	AccountKeeper feegrant.AccountKeeper `key:"cosmos.auth.v1.AccountKeeper"`
-	BankKeeper    feegrant.BankKeeper    `key:"cosmos.bank.v1.Keeper"`
+	AccountKeeper feegrant.AccountKeeper
+	BankKeeper    feegrant.BankKeeper
 	Registry      cdctypes.InterfaceRegistry
 }
 

x/staking/module.go

@@ -197,8 +197,8 @@ type stakingInputs struct {
 	depinject.In
 
 	Config        *modulev1.Module
-	AccountKeeper types.AccountKeeper `key:"cosmos.auth.v1.AccountKeeper"`
-	BankKeeper    types.BankKeeper    `key:"cosmos.bank.v1.Keeper"`
+	AccountKeeper types.AccountKeeper
+	BankKeeper    types.BankKeeper
 	Cdc           codec.Codec
 	Subspace      paramstypes.Subspace
 	Key           *store.KVStoreKey
@@ -208,7 +208,7 @@ type stakingInputs struct {
 type stakingOutputs struct {
 	depinject.Out
 
-	StakingKeeper *keeper.Keeper `key:"cosmos.staking.v1.Keeper"`
+	StakingKeeper *keeper.Keeper
 	Module        runtime.AppModuleWrapper
 }