type go.pact.im/x/plumb/internal/solve.Instance
50 uses
go.pact.im/x/plumb/internal/solve (current package)
finalize.go#L27: Args: map[*Instance][]ArgRef{},
finalize.go#L115: func (s *solver) resolveInput(in *Instance, inp InputSlot) (ArgRef, *diag.Error) {
finalize.go#L131: func sortTypesByProducer(ts []types.Type, supply *gotypes.Map[types.Type, *Instance]) {
finalize.go#L132: producer := func(t types.Type) *Instance {
instance.go#L49: type Instance struct {
instance.go#L59: func (in *Instance) valueOuts() []types.Type {
instance.go#L70: func (in *Instance) InputTypes() []types.Type {
instance.go#L87: func instantiate(p *discover.Provider, ctxt *types.Context, targs []types.Type) (in *Instance, err *diag.Error, miss error) {
instance.go#L88: in = &Instance{Prov: p, Targs: targs, pos: p.Pos}
instance.go#L235: func classifyParams(in *Instance, sig *types.Signature, start int) {
instance.go#L245: func classifyResults(p *discover.Provider, in *Instance, sig *types.Signature) *diag.Error {
order.go#L25: func (s *solver) topoOrder(pl *Plan) ([]*Instance, *diag.Error) {
order.go#L26: insts := slices.SortedStableFunc(slices.Values(s.instances), func(a, b *Instance) int { return diag.CmpPos(a.pos, b.pos) })
order.go#L29: deps := map[*Instance]map[*Instance]bool{}
order.go#L31: deps[in] = map[*Instance]bool{}
order.go#L44: emitted := map[*Instance]bool{}
order.go#L45: var order []*Instance
order.go#L75: func (s *solver) cycleError(pl *Plan, insts []*Instance, emitted map[*Instance]bool, deps map[*Instance]map[*Instance]bool) *diag.Error {
order.go#L76: var remaining []*Instance
order.go#L87: color := map[*Instance]int{}
order.go#L88: var stack []*Instance
order.go#L89: var cycle []*Instance
order.go#L91: var dfs func(in *Instance) bool
order.go#L92: dfs = func(in *Instance) bool {
order.go#L96: var nbrs []*Instance
order.go#L102: slices.SortStableFunc(nbrs, func(a, b *Instance) int { return diag.CmpPos(a.pos, b.pos) })
order.go#L109: cycle = append([]*Instance{}, stack[i:]...)
order.go#L162: func (s *solver) edgeType(pl *Plan, consumer, producer *Instance) (types.Type, bool) {
solve.go#L128: Order []*Instance // instances to emit, in dependency (topological) order
solve.go#L129: Args map[*Instance][]ArgRef // each instance's inputs, one ArgRef per input in order
solve.go#L159: concrete []*Instance // concrete providers, instantiated during classification
solve.go#L163: instances []*Instance
solve.go#L164: supply gotypes.Map[types.Type, *Instance] // type → producing instance (exact), by type identity
solve.go#L170: skel map[*discover.Provider]*Instance // provider → memoized own-params skeleton
solve.go#L191: pinnings map[*Instance]map[*types.TypeParam]types.Type
solve.go#L227: skel: map[*discover.Provider]*Instance{},
solve.go#L234: pinnings: map[*Instance]map[*types.TypeParam]types.Type{},
solve.go#L459: func (s *solver) skeleton(p *discover.Provider) *Instance {
solve.go#L611: func (s *solver) addInstance(in *Instance) *diag.Error {
solve.go#L674: func (s *solver) shadowedDemand(p *discover.Provider) (types.Type, *Instance, types.Type) {
solve.go#L701: func (s *solver) templateServes(p *discover.Provider, skel *Instance, params map[*types.TypeParam]bool, d types.Type) bool {
solve.go#L748: func (s *solver) checkInputType(in *Instance, t types.Type) *diag.Error {
solve.go#L822: func ambiguousProducers(a, b *Instance, t types.Type) *diag.Error {
go.pact.im/x/plumb/internal/emit
emit.go#L434: func instanceFallible(in *solve.Instance) bool {
render.go#L16: func renderInstance(in *solve.Instance, q *qualifier, args []string) string {
report.go#L87: func joinResults(in *solve.Instance, q func(types.Type) string) string {