dig.go: Split into files by purpose (uber-go#303)

The dig.go file has grown past readability.
Break it apart into separate files:

- constructor.go defines constructorNode, its method, and the ability
  to call a constructor.
- container.go defines the container type and its related interfaces and
  methods.
- types.go was renamed to inout.go, defining the In and Out types.
- invoke.go defines the Invoke method of the Container type.
- provide.go does the same for the provide method of the Container type.
- stringer.go was deleted in favor of string methods next to their
  types.

This change contains no behavioral changes. Code has only been moved.

Co-authored-by: Sung Yoon Whang <[email protected]>

Author: abhinav

constructor.go

@@ -0,0 +1,187 @@
+// Copyright (c) 2021 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package dig
+
+import (
+	"fmt"
+	"reflect"
+
+	"go.uber.org/dig/internal/digreflect"
+	"go.uber.org/dig/internal/dot"
+)
+
+// constructorNode is a node in the dependency graph that represents
+// a constructor provided by the user.
+//
+// constructorNodes can produce zero or more values that they store into the container.
+// For the Provide path, we verify that constructorNodes produce at least one value,
+// otherwise the function will never be called.
+type constructorNode struct {
+	ctor  interface{}
+	ctype reflect.Type
+
+	// Location where this function was defined.
+	location *digreflect.Func
+
+	// id uniquely identifies the constructor that produces a node.
+	id dot.CtorID
+
+	// Whether the constructor owned by this node was already called.
+	called bool
+
+	// Type information about constructor parameters.
+	paramList paramList
+
+	// Type information about constructor results.
+	resultList resultList
+
+	order int // order of this node in graphHolder
+}
+
+type constructorOptions struct {
+	// If specified, all values produced by this constructor have the provided name
+	// belong to the specified value group or implement any of the interfaces.
+	ResultName  string
+	ResultGroup string
+	ResultAs    []interface{}
+	Location    *digreflect.Func
+}
+
+func newConstructorNode(ctor interface{}, c containerStore, opts constructorOptions) (*constructorNode, error) {
+	cval := reflect.ValueOf(ctor)
+	ctype := cval.Type()
+	cptr := cval.Pointer()
+
+	params, err := newParamList(ctype, c)
+	if err != nil {
+		return nil, err
+	}
+
+	results, err := newResultList(
+		ctype,
+		resultOptions{
+			Name:  opts.ResultName,
+			Group: opts.ResultGroup,
+			As:    opts.ResultAs,
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	location := opts.Location
+	if location == nil {
+		location = digreflect.InspectFunc(ctor)
+	}
+
+	n := &constructorNode{
+		ctor:       ctor,
+		ctype:      ctype,
+		location:   location,
+		id:         dot.CtorID(cptr),
+		paramList:  params,
+		resultList: results,
+	}
+	n.order = c.newGraphNode(n)
+	return n, nil
+}
+
+func (n *constructorNode) Location() *digreflect.Func { return n.location }
+func (n *constructorNode) ParamList() paramList       { return n.paramList }
+func (n *constructorNode) ResultList() resultList     { return n.resultList }
+func (n *constructorNode) ID() dot.CtorID             { return n.id }
+func (n *constructorNode) CType() reflect.Type        { return n.ctype }
+func (n *constructorNode) Order() int                 { return n.order }
+
+func (n *constructorNode) String() string {
+	return fmt.Sprintf("deps: %v, ctor: %v", n.paramList, n.ctype)
+}
+
+// Call calls this constructor if it hasn't already been called and
+// injects any values produced by it into the provided container.
+func (n *constructorNode) Call(c containerStore) error {
+	if n.called {
+		return nil
+	}
+
+	if err := shallowCheckDependencies(c, n.paramList); err != nil {
+		return errMissingDependencies{
+			Func:   n.location,
+			Reason: err,
+		}
+	}
+
+	args, err := n.paramList.BuildList(c)
+	if err != nil {
+		return errArgumentsFailed{
+			Func:   n.location,
+			Reason: err,
+		}
+	}
+
+	receiver := newStagingContainerWriter()
+	results := c.invoker()(reflect.ValueOf(n.ctor), args)
+	if err := n.resultList.ExtractList(receiver, results); err != nil {
+		return errConstructorFailed{Func: n.location, Reason: err}
+	}
+	receiver.Commit(c)
+	n.called = true
+
+	return nil
+}
+
+// stagingContainerWriter is a containerWriter that records the changes that
+// would be made to a containerWriter and defers them until Commit is called.
+type stagingContainerWriter struct {
+	values map[key]reflect.Value
+	groups map[key][]reflect.Value
+}
+
+var _ containerWriter = (*stagingContainerWriter)(nil)
+
+func newStagingContainerWriter() *stagingContainerWriter {
+	return &stagingContainerWriter{
+		values: make(map[key]reflect.Value),
+		groups: make(map[key][]reflect.Value),
+	}
+}
+
+func (sr *stagingContainerWriter) setValue(name string, t reflect.Type, v reflect.Value) {
+	sr.values[key{t: t, name: name}] = v
+}
+
+func (sr *stagingContainerWriter) submitGroupedValue(group string, t reflect.Type, v reflect.Value) {
+	k := key{t: t, group: group}
+	sr.groups[k] = append(sr.groups[k], v)
+}
+
+// Commit commits the received results to the provided containerWriter.
+func (sr *stagingContainerWriter) Commit(cw containerWriter) {
+	for k, v := range sr.values {
+		cw.setValue(k.name, k.t, v)
+	}
+
+	for k, vs := range sr.groups {
+		for _, v := range vs {
+			cw.submitGroupedValue(k.group, k.t, v)
+		}
+	}
+}