fix(plan): exclude the container's own constructor from by-type lookup

Author: mickamy

internal/plan/plan.go

@@ -111,12 +111,14 @@ func Build(c ir.Container, idx *Index, opts Options) (Plan, []diag.Diag) {
 	diags = append(diags, emDiags...)
 
 	r := &resolver{
-		idx:       idx,
-		inputs:    inputs,
-		overrides: overrides,
-		embeds:    embeds,
-		stepByKey: map[string]int{},
-		active:    map[string]bool{},
+		idx:          idx,
+		inputs:       inputs,
+		overrides:    overrides,
+		embeds:       embeds,
+		stepByKey:    map[string]int{},
+		active:       map[string]bool{},
+		selfPkgPath:  c.PkgPath,
+		selfFuncName: constructorName,
 	}
 
 	var outputs []Output
@@ -175,6 +177,15 @@ type resolver struct {
 	steps     []Step
 	stepByKey map[string]int
 	active    map[string]bool
+
+	// selfPkgPath and selfFuncName identify this container's own
+	// generated constructor. They are used to filter the by-type lookup
+	// so a container whose `inject:"returns"` declares an interface that
+	// matches an unrelated provider does not see its own previously
+	// emitted constructor as a candidate (a self-loop that would also
+	// produce a spurious "multiple providers" error).
+	selfPkgPath  string
+	selfFuncName string
 }
 
 // embedSource describes one exported field of an inject:"embed" input that
@@ -192,6 +203,24 @@ func (r *resolver) resolveField(f ir.Field) (int, []diag.Diag) {
 	return r.resolveByType(f.Type, f.Pos, "field "+f.Name)
 }
 
+// excludeSelfProvider drops the container's own previously generated
+// constructor from the candidate list so a `inject:"returns"` field does
+// not pick itself up via type lookup. Callers that name a provider
+// explicitly via inject:"with=..." are not affected.
+func (r *resolver) excludeSelfProvider(candidates []*ir.Provider) []*ir.Provider {
+	if r.selfFuncName == "" {
+		return candidates
+	}
+	kept := candidates[:0:0]
+	for _, c := range candidates {
+		if c.PkgPath == r.selfPkgPath && c.FuncName == r.selfFuncName {
+			continue
+		}
+		kept = append(kept, c)
+	}
+	return kept
+}
+
 func (r *resolver) resolveByType(want types.Type, pos token.Position, parent string) (int, []diag.Diag) {
 	tk := TypeKey(want)
 
@@ -210,6 +239,7 @@ func (r *resolver) resolveByType(want types.Type, pos token.Position, parent str
 	}
 
 	candidates := r.idx.LookupByType(want)
+	candidates = r.excludeSelfProvider(candidates)
 	if len(candidates) == 0 {
 		return -1, []diag.Diag{
 			diag.Errorf(pos, "no provider for %s (required by %s)", TypeString(want), parent),

internal/plan/plan_test.go

@@ -344,6 +344,35 @@ type Container struct {
 	}
 }
 
+func TestBuild_SelfGeneratedProviderIgnored(t *testing.T) {
+	t.Parallel()
+
+	// A `inject:"returns"` container whose previously generated
+	// constructor is now visible to the provider scan must not pick that
+	// constructor up as a candidate when resolving its own field, or it
+	// would loop forever. The unrelated, non-self provider remains usable.
+	src := `package test
+type Greeter interface{ Greet() string }
+type greeterImpl struct{}
+func (greeterImpl) Greet() string { return "" }
+func NewGreeterImpl() Greeter { return greeterImpl{} }
+
+// Pretend this came from a previous generation of NewWrapper.
+func NewWrapper() Greeter { return nil }
+
+type wrapper struct {
+	service Greeter ` + "`inject:\"returns\"`" + `
+}
+`
+	p, ds := build(t, src, "wrapper", plan.Options{})
+	if diag.HasErrors(ds) {
+		t.Fatalf("expected the self provider NewWrapper to be filtered out, got %v", ds)
+	}
+	if len(p.Steps) != 1 || p.Steps[0].Provider == nil || p.Steps[0].Provider.FuncName != "NewGreeterImpl" {
+		t.Errorf("expected NewGreeterImpl to be the only provider step; got %+v", p.Steps)
+	}
+}
+
 func TestBuild_FieldNameTakenForcesSuffix(t *testing.T) {
 	t.Parallel()