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

[OutUniverse]

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 }

[OutUniverse]

Here is the error:

[ProgrammingMuffin]

Have you tried passing NewITestBService provider to TestAServiceSet? It cannot find this specific provider. Here is an example I tried which works:

inner/inner.go:

package inner

type TextValue struct {
	Value string
}

main.go:

//go:build wireinject
// +build wireinject

package main

import (
	"fmt"
	"wiretest/inner"

	"github.com/google/wire"
)

type Message struct {
	Text inner.TextValue
}

func ProvideString() inner.TextValue {
	return inner.TextValue{Value: "hi"}
}

func InitializeEvent() Message {
	wire.Build(wire.NewSet(wire.Struct(new(Message), "Text"), ProvideString))
	return Message{}
}

func main() {
	m := InitializeEvent()
	fmt.Println("message is: ", m.Text.Value)
}

Please correct me if I am not understanding the issue correctly.

[dimuska139]

@OutUniverse I faced a similar problem. Wire showed a similar uninformative error. It turned out that the problem was caused by a cyclic import. I see it in your example too. services package imports inpack in a.go and inpack imports services in b.go.