Injecting the subpackage into the parent package results in the error "no provider found for invalid type".

The a.go could not injector the b.go interface, but the d.go is ok.

The directory struct like this:

services - a.go - c.go inpack - b.go testinpack - d.go

Here is the code: a.go:

package services

import ( "github.com/google/wire" "test.com/services/inpack" )

var TestAServiceSet = wire.NewSet(wire.Struct(new(TestAServiceDI), "*"), NewTestAService, NewITestAService)

type TestAServiceDI struct { bservice inpack.ITestBService }

type TestAService struct { serviceDI TestAServiceDI }

func NewTestAService(serviceDI TestAServiceDI) *TestAService { return &TestAService{serviceDI} }

type ITestAService interface { }

func NewITestAService(service *TestAService) ITestAService { return service }

c.go:

package services

import ( "github.com/google/wire" )

var TestCServiceSet = wire.NewSet(wire.Struct(new(TestCServiceDI), "*"), NewTestCService, NewITestCService)

type TestCServiceDI struct { }

type TestCService struct { serviceDI TestCServiceDI }

func NewTestCService(serviceDI TestCServiceDI) *TestCService { return &TestCService{serviceDI} }

type ITestCService interface { }

func NewITestCService(service *TestCService) ITestCService { return service }

b.go:

package inpack

import ( "test.com/services"

复制

"github.com/google/wire"

)

var TestBServiceSet = wire.NewSet(wire.Struct(new(TestBServiceDI), "*"), NewTestBService, NewITestBService)

type TestBServiceDI struct { c services.ITestCService }

type TestBService struct { serviceDI TestBServiceDI }

func NewTestBService(serviceDI TestBServiceDI) *TestBService { return &TestBService{serviceDI} }

type ITestBService interface { }

func NewITestBService(service *TestBService) ITestBService { return service }

d.go:

package testinpack

import ( "github.com/google/wire" "test.com/services/inpack" )

var TestDServiceSet = wire.NewSet(wire.Struct(new(TestDServiceDI), "*"), NewTestDService, NewITestDService)

type TestDServiceDI struct { bservice inpack.ITestBService }

type TestDService struct { serviceDI TestDServiceDI }

func NewTestDService(serviceDI TestDServiceDI) *TestDService { return &TestDService{serviceDI} }

type ITestDService interface { }

func NewITestDService(service *TestDService) ITestDService { return service }