make Unused{} a special type

Author: muir

api.go

@@ -579,11 +579,3 @@ func (c *Collection) MustSetCallback(binderFunction interface{}) {
 		panic(DetailedError(err))
 	}
 }
-
-type unused struct{}
-
-// Unused is value that a function that returns injectors can return that will never be
-// included in an injection chain. Unused can be used in situations where you want to
-// call a function as part of generating a list of injectors and functions in such a list
-// must have a return value.
-var Unused = Provide("unused", unused{})

bind.go

@@ -14,7 +14,7 @@ func doBind(sc *Collection, originalInvokeF *provider, originalInitF *provider,
 	var invokeF *provider
 	var initF *provider
 	var debuggingProvider **provider
-	funcs := make([]*provider, 0, len(sc.contents)+3)
+	funcs := make([]*provider, 0, len(sc.contents)+5)
 	{
 		var err error
 		invokeF, err = characterizeInitInvoke(originalInvokeF, charContext{inputsAreStatic: false})
@@ -61,10 +61,46 @@ func doBind(sc *Collection, originalInvokeF *provider, originalInitF *provider,
 		funcs = append(funcs, invokeF)
 		funcs = append(funcs, afterInvoke...)
 
+		var consumesUnused bool
+		var receivesUnused bool
 		for _, fm := range funcs {
 			if fm.required {
 				fm.include = true
 			}
+			for _, in := range fm.flows[inputParams] {
+				if in == unusedTypeCode {
+					consumesUnused = true
+				}
+			}
+			for _, in := range fm.flows[bypassParams] {
+				if in == unusedTypeCode {
+					consumesUnused = true
+				}
+			}
+			for _, in := range fm.flows[receivedParams] {
+				if in == unusedTypeCode {
+					receivesUnused = true
+				}
+			}
+		}
+		if consumesUnused {
+			funcs = append(funcs, nil)
+			for i := len(funcs) - 1; i > 0; i-- {
+				funcs[i] = funcs[i-1]
+			}
+			d, err := makeUnusedInputProvider()
+			if err != nil {
+				return err
+			}
+			funcs[0] = d
+		}
+		if receivesUnused {
+			d, err := makeUnusedReturnsProvider()
+			if err != nil {
+				return err
+			}
+			funcs = append(funcs, d)
+			funcs[len(funcs)-1], funcs[len(funcs)-2] = funcs[len(funcs)-2], funcs[len(funcs)-1]
 		}
 	}
 
@@ -406,6 +442,7 @@ func addToVmap(fm *provider, param flowType, vMap map[typeCode]int, rMap map[typ
 
 func makeDebuggingProvider() (*provider, error) {
 	d := newProvider(func() *Debugging { return nil }, -1, "Debugging")
+	d.nonFinal = true
 	d.cacheable = true
 	d.mustCache = true
 	d, err := characterizeFunc(d, charContext{inputsAreStatic: true})
@@ -415,3 +452,32 @@ func makeDebuggingProvider() (*provider, error) {
 	d.isSynthetic = true
 	return d, nil
 }
+
+func makeUnusedInputProvider() (*provider, error) {
+	d := newProvider(Unused{}, -1, "provide unused")
+	d.nonFinal = true
+	d.cacheable = true
+	d.mustCache = true
+	d.consumptionOptional = true
+	d, err := characterizeFunc(d, charContext{inputsAreStatic: true})
+	if err != nil {
+		return nil, fmt.Errorf("internal error #328: problem with unused injectors: %w", err)
+	}
+	d.isSynthetic = true
+	d.shun = true
+	return d, nil
+}
+
+func makeUnusedReturnsProvider() (*provider, error) {
+	d := newProvider(func(inner func()) Unused { inner(); return Unused{} }, -1, "return unused")
+	d.nonFinal = true
+	d, err := characterizeFunc(d, charContext{inputsAreStatic: true})
+	if err != nil {
+		return nil, fmt.Errorf("internal error #278: problem with unused injectors: %w", err)
+	}
+	d.isSynthetic = true
+	d.shun = true
+	d.required = false
+	d.consumptionOptional = true
+	return d, nil
+}

bind_test.go

@@ -305,9 +305,6 @@ func TestLiteral(t *testing.T) {
 		counts := make(map[string]int)
 		c := Sequence("TBF",
 			s1("s1 value"),
-			func() Provider {
-				return Unused
-			}(),
 			Cacheable(func(s s1) s2 {
 				counts["s2"]++
 				assert.Equal(t, s1("s1 value"), s)

characterize.go

@@ -140,7 +140,7 @@ var (
 	notLast              = predicate("must not be last", func(a testArgs) bool { return !a.cc.isLast })
 	unstaticOkay         = predicate("is marked MustCache", func(a testArgs) bool { return !a.fm.mustCache })
 	inStatic             = predicate("is after invoke", func(a testArgs) bool { return a.cc.inputsAreStatic })
-	hasOutputs           = predicate("does not have outputs", func(a testArgs) bool { return a.t.NumOut() != 0 })
+	hasOutputs           = predicate("does not have outputs", func(a testArgs) bool { return len(stripUnused(typesOut(a.t))) != 0 })
 	mustNotMemoize       = predicate("is marked Memoized", func(a testArgs) bool { return !a.fm.memoize })
 	markedMemoized       = predicate("is not marked Memoized", func(a testArgs) bool { return a.fm.memoize })
 	markedCacheable      = predicate("is not marked Cacheable", func(a testArgs) bool { return a.fm.cacheable })

characterize_test.go

@@ -274,6 +274,28 @@ var characterizeTests = []struct {
 			returns(intTC, errorTC).
 			returned(errorTC, intType3TC),
 	},
+	{
+		"middleware func return int",
+		func(func() intType3) {},
+		wrapperFunc,
+		lastF, staticT, panicF,
+		params().
+			input(noTypeCode).
+			output().
+			returns().
+			returned(intType3TC),
+	},
+	{
+		"middleware func return unused",
+		func(func() Unused) {},
+		wrapperFunc,
+		lastF, staticT, panicF,
+		params().
+			input(noTypeCode).
+			output().
+			returns().
+			returned(unusedTypeCode),
+	},
 	{
 		"simple middleware regression",
 		func(i func() error, w http.ResponseWriter) {},

flows.go

@@ -184,3 +184,37 @@ func (c Collection) UpFlows() ([]reflect.Type, []reflect.Type) {
 		return fm.UpFlows()
 	})
 }
+
+// stirpUnused redacts unusedType from lists
+func stripUnused(list []reflect.Type) []reflect.Type {
+	for i, t := range list {
+		if t == unusedType {
+			n := make([]reflect.Type, i, len(list)-1)
+			copy(n, list[:i])
+			for _, t := range list[i+1:] {
+				if t != unusedType {
+					n = append(n, t)
+				}
+			}
+			return n
+		}
+	}
+	return list
+}
+
+// stirpUnusedCode redacts unusedTypeCode from lists
+func stripUnusedCodes(list []typeCode) []typeCode {
+	for i, t := range list {
+		if t == unusedTypeCode {
+			n := make([]typeCode, i, len(list)-1)
+			copy(n, list[:i])
+			for _, t := range list[i+1:] {
+				if t != unusedTypeCode {
+					n = append(n, t)
+				}
+			}
+			return n
+		}
+	}
+	return list
+}

include.go

@@ -88,7 +88,7 @@ func computeDependenciesAndInclusion(funcs []*provider, initF *provider) ([]*pro
 			fm.whyIncluded = "required"
 		} else if fm.desired {
 			fm.whyIncluded = "desired"
-		} else if fm.flows[outputParams] != nil && len(fm.flows[outputParams]) == 0 {
+		} else if fm.flows[outputParams] != nil && len(stripUnusedCodes(fm.flows[outputParams])) == 0 {
 			fm.whyIncluded = "auto-desired (injector with no outputs)"
 			if fm.cluster != 0 {
 				fm.d.wantedInCluster = true
@@ -138,7 +138,7 @@ func computeDependenciesAndInclusion(funcs []*provider, initF *provider) ([]*pro
 	}
 
 	debugln("eliminate unused providers")
-	eliminateUnused(funcs) // xxx
+	eliminateUnused(funcs)
 
 	tryWithout := func(without ...*provider) {
 		if len(without) == 1 {
@@ -308,6 +308,9 @@ func checkFlows(funcs []*provider, numFuncs int, canRemoveDesired bool) error {
 				}
 			Param:
 				for _, tc := range tclist {
+					if tc == unusedTypeCode {
+						continue
+					}
 					var extra string
 					for _, p := range fm.d.usedByDetail[param][tc] {
 						if p.include {

type_codes.go

@@ -9,8 +9,10 @@ import (
 	"github.com/muir/reflectutils"
 )
 
-type typeCode int
-type typeCodes []typeCode
+type (
+	typeCode  int
+	typeCodes []typeCode
+)
 
 var (
 	typeCounter = 0
@@ -25,6 +27,8 @@ const noTypeExampleValue noType = false
 
 var noTypeCode = getTypeCode(noTypeExampleValue)
 
+var unusedTypeCode = getTypeCode(unusedType)
+
 // noNoType filters out noTypeCode from an array of typeCode
 func noNoType(types []typeCode) []typeCode {
 	found := -1

types.go

@@ -66,6 +66,12 @@ type Debugging struct {
 	Outer *Debugging
 }
 
+// Unused is a special type: as an input, it will be provided automatically. If output from a
+// MustConsume provider, no consumer is needed. If an injector only returns Unused, then that
+// injector will be included in the chain, if possible, same as an injector that doesn't return
+// anything at all.
+type Unused struct{}
+
 type classType int
 
 const (
@@ -121,4 +127,6 @@ var (
 	bypassDebugType = reflect.TypeOf((**bypassDebug)(nil)).Elem()
 
 	reflectiveFuncType = reflect.TypeOf((*func([]reflect.Type) []reflect.Type)(nil)).Elem()
+
+	unusedType = reflect.TypeOf((*Unused)(nil)).Elem()
 )