use go:generate and stringer to replace maps with arrays for performance

.golangci.yaml

@@ -84,6 +84,8 @@ linters:
   enable:
     - megacheck
     - govet
+    - exportloopref
+    - errcheck
   enable-all: false
   disable:
     - maligned
@@ -92,6 +94,7 @@ linters:
     - funlen
     - gocognit
     - gocyclo
+    - scopelint
   presets:
     - bugs
     - unused

Makefile

@@ -0,0 +1,7 @@
+
+
+all:
+	go install golang.org/x/tools/...@latest
+	go generate
+	go test
+	golangci-lint run

bind.go

@@ -21,9 +21,6 @@ func doBind(sc *Collection, originalInvokeF *provider, originalInitF *provider,
 		if err != nil {
 			return err
 		}
-		if invokeF.flows == nil {
-			return fmt.Errorf("internal error #4: no flows for invoke")
-		}
 		nonStaticTypes := make(map[typeCode]bool)
 		for _, tc := range invokeF.flows[outputParams] {
 			nonStaticTypes[tc] = true
@@ -59,9 +56,6 @@ func doBind(sc *Collection, originalInvokeF *provider, originalInitF *provider,
 			if err != nil {
 				return err
 			}
-			if initF.flows == nil {
-				return fmt.Errorf("internal error #5: no flows for initF")
-			}
 			funcs = append(funcs, initF)
 		}
 

characterize.go

@@ -13,7 +13,7 @@ type charContext struct {
 	inputsAreStatic bool
 }
 
-type flowMapType map[flowType][]typeCode
+type flowMapType [bypassParams + 1][]typeCode
 
 type characterization struct {
 	name   string
@@ -525,7 +525,7 @@ Match:
 		}
 		a.fm.upRmap = make(map[typeCode]typeCode)
 		a.fm.downRmap = make(map[typeCode]typeCode)
-		a.fm.flows = make(flowMapType)
+		a.fm.flows = [lastFlowType][]typeCode{}
 		match.mutate(a)
 		return a.fm, nil
 	}

characterize_test.go

@@ -52,7 +52,7 @@ type doesJ struct {
 func (dj *doesJ) I() int { return dj.j * 3 }
 
 func params() flowMapType {
-	return make(flowMapType)
+	return [bypassParams + 1][]typeCode{}
 }
 
 func (flows flowMapType) returns(f ...typeCode) flowMapType {
@@ -185,21 +185,21 @@ var characterizeTests = []struct {
 		func() {},
 		injectorFunc,
 		lastF, staticF, panicF,
-		nil,
+		params(),
 	},
 	{
 		"cacheable notCacheable",
 		Cacheable(NotCacheable(func() {})),
 		injectorFunc,
 		lastF, staticT, panicF,
-		nil,
+		params(),
 	},
 	{
 		"cacheable notCacheable",
 		Cacheable(NotCacheable(func() {})),
 		injectorFunc,
 		lastF, staticF, panicF,
-		nil,
+		params(),
 	},
 	{
 		"minimal fallible injector",
@@ -244,14 +244,14 @@ var characterizeTests = []struct {
 		func(int) func() { return func() {} },
 		finalFunc,
 		lastT, staticF, panicT,
-		nil,
+		params(),
 	},
 	{
 		"invalid: anonymous func that isn't a wrap #2",
 		func(func(), int) {},
 		finalFunc,
 		lastT, staticF, panicT,
-		nil,
+		params(),
 	},
 	{
 		"middleware func",
@@ -296,14 +296,14 @@ var characterizeTests = []struct {
 		&nadaFunc,
 		invokeFunc,
 		lastF, staticF, panicF,
-		nil,
+		params(),
 	},
 	{
 		"init: nada",
 		&nadaFunc,
 		initFunc,
 		lastF, staticT, panicF,
-		nil,
+		params(),
 	},
 	{
 		"literal: int",
@@ -317,7 +317,7 @@ var characterizeTests = []struct {
 		"foobar",
 		literalValue,
 		lastF, staticF, panicT,
-		nil,
+		params(),
 	},
 }
 
@@ -389,13 +389,13 @@ func TestCharacterize(t *testing.T) {
 				}
 			}
 			for ft, ev := range test.flows {
-				t.Logf("flow %s: %s", ft, een(ev))
-				assert.EqualValues(t, een(ev), een(fm.flows[ft]), fmt.Sprintf("%s flow: %s", ft, test.name))
+				t.Logf("flow %s: %s", flowType(ft), een(ev))
+				assert.EqualValues(t, een(ev), een(fm.flows[ft]), fmt.Sprintf("%s flow: %s", flowType(ft), test.name))
 			}
 			for ft, gv := range fm.flows {
 				if test.flows[ft] == nil {
-					t.Logf("flow %s: %s", ft, een(gv))
-					assert.EqualValues(t, een(test.flows[ft]), een(gv), fmt.Sprintf("%s flow %s", ft, test.name))
+					t.Logf("flow %s: %s", flowType(ft), een(gv))
+					assert.EqualValues(t, een(test.flows[ft]), een(gv), fmt.Sprintf("%s flow %s", flowType(ft), test.name))
 				}
 			}
 		}

debug.go

@@ -132,7 +132,7 @@ func dumpF(context string, fm *provider) {
 	out += fmt.Sprintf("\n\tclass: %s\n\tgroup: %s", fm.class, fm.group)
 	for name, flow := range fm.flows {
 		if len(flow) > 0 {
-			out += fmt.Sprintf("\n\t%s flow: %s", name, formatFlow(flow))
+			out += fmt.Sprintf("\n\t%s flow: %s", flowType(name), formatFlow(flow))
 		}
 	}
 	for upDown, rMap := range map[string]map[typeCode]typeCode{
@@ -168,7 +168,7 @@ func dumpF(context string, fm *provider) {
 	}
 	for param, users := range fm.d.usesDetail {
 		for tc, dep := range users {
-			out += fmt.Sprintf("\n\tUSES: %s (%s %s)", dep, param, tc)
+			out += fmt.Sprintf("\n\tUSES: %s (%s %s)", dep, flowType(param), tc)
 		}
 	}
 	for _, dep := range fm.d.usedBy {

generate.go

@@ -31,10 +31,7 @@ func generateParameterMap(
 	vmap map[typeCode]int, // map of types in valueCollection to their positions
 	purpose string, // debug string
 ) (parameterMap, error) {
-	flow, found := fm.flows[param]
-	if !found {
-		return parameterMap{}, fm.errorf("internal error #12: flow %s missing", param)
-	}
+	flow := fm.flows[param]
 	m := make([]int, len(flow))
 	types := make([]reflect.Type, len(flow))
 	for i, p := range flow {
@@ -380,6 +377,8 @@ func generateWrappers(
 	case invokeFunc, initFunc, literalValue:
 		// handled elsewhere
 		return nil
+	case unsetClassType:
+		fallthrough
 	default:
 		return fmt.Errorf("internal error #11: unexpected class")
 	}

include.go

@@ -5,12 +5,12 @@ import (
 )
 
 type includeWorkingData struct {
-	usesDetail      map[flowType]map[typeCode][]*provider
+	usesDetail      [lastFlowType]map[typeCode][]*provider
 	uses            []*provider
-	usesError       map[flowType]map[typeCode]error
+	usesError       [lastFlowType]map[typeCode]error
 	usedBy          []*provider
-	usedByDetail    map[flowType]map[typeCode][]*provider
-	mustConsumeFlow map[flowType]bool
+	usedByDetail    [lastFlowType]map[typeCode][]*provider
+	mustConsumeFlow [lastFlowType]bool
 	excluded        error
 	clusterMembers  []*provider
 	wantedInCluster bool
@@ -78,7 +78,7 @@ func computeDependenciesAndInclusion(funcs []*provider, initF *provider) error {
 				fm.d.clusterMembers = []*provider{fm}
 			}
 		}
-		fm.d.mustConsumeFlow = make(map[flowType]bool)
+		fm.d.mustConsumeFlow = [lastFlowType]bool{}
 		if fm.mustConsume {
 			fm.d.mustConsumeFlow[outputParams] = true
 		}
@@ -276,7 +276,7 @@ func checkFlows(funcs []*provider, numFuncs int, canRemoveDesired bool) error {
 						debugf("\t\t\tcannot provide %s %s: %s: %s", param, tc, p, p.cannotInclude)
 						extra = fmt.Sprintf(" (not provided by %s because %s)", p, p.cannotInclude)
 					}
-					fm.cannotInclude = fmt.Errorf("no provider for %s in %s%s", tc, param, extra)
+					fm.cannotInclude = fmt.Errorf("no provider for %s in %s%s", tc, flowType(param), extra)
 					redo = append(redo, fm)
 					debugf("\t\tno source %s %s  %s: %s", param, tc, fm, fm.cannotInclude)
 					continue Todo
@@ -299,7 +299,7 @@ func checkFlows(funcs []*provider, numFuncs int, canRemoveDesired bool) error {
 						debugf("\t\t\tcannot consume %s %s: %s: %s", param, tc, p, p.cannotInclude)
 						extra = fmt.Sprintf(" (not consumed by %s because %s)", p, p.cannotInclude)
 					}
-					fm.cannotInclude = fmt.Errorf("no consumer for %s in %s%s", tc, param, extra)
+					fm.cannotInclude = fmt.Errorf("no consumer for %s in %s%s", tc, flowType(param), extra)
 					redo = append(redo, fm)
 					debugf("\t\tnot consumed %s %s %s: %s", param, tc, fm, fm.cannotInclude)
 					continue Todo
@@ -317,10 +317,10 @@ func checkFlows(funcs []*provider, numFuncs int, canRemoveDesired bool) error {
 func providesReturns(funcs []*provider, initF *provider) error {
 	debugln("calculating provides/returns")
 	for _, fm := range funcs {
-		fm.d.usedByDetail = make(map[flowType]map[typeCode][]*provider)
-		fm.d.usesDetail = make(map[flowType]map[typeCode][]*provider)
+		fm.d.usedByDetail = [lastFlowType]map[typeCode][]*provider{}
+		fm.d.usesDetail = [lastFlowType]map[typeCode][]*provider{}
 		fm.d.uses = nil
-		fm.d.usesError = make(map[flowType]map[typeCode]error)
+		fm.d.usesError = [lastFlowType]map[typeCode]error{}
 		fm.d.usedBy = nil
 	}
 	provide := make(interfaceMap)

nject.go

@@ -162,8 +162,8 @@ func (fm *provider) String() string {
 		t = reflect.TypeOf(fm.fn).String()
 	}
 	class := ""
-	if fm.class != "" {
-		class = string(fm.class) + ": "
+	if fm.class != unsetClassType {
+		class = fm.class.String() + ": "
 	}
 	if fm.index >= 0 {
 		return fmt.Sprintf("%s%s(%d) [%s]", class, fm.origin, fm.index, t)