Support Parameter Objects

[abhinav]

This adds support for parameter objects to Dig. Parameter objects are arguments
to a constructor which contain zero or more fields that are the actual
dependencies for the constructor. Users opt-in for a struct to be interpreted
as a parameter object by embedding the dig.Param type into it.

type Config struct {
    dig.Param

    In io.Reader
    Out io.Writer
}

func NewTransport(c Config) (*Transport, error) {
    // ..
}

[coveralls]

Coverage increased (+0.9%) to 90.213% when pulling 80fdf72 on parameter-objects into 13204cd on ajs-fix-behavior-tests.

[coveralls]

Coverage increased (+0.9%) to 90.213% when pulling 80fdf72 on parameter-objects into 13204cd on ajs-fix-behavior-tests.

[coveralls]

Coverage increased (+0.9%) to 90.129% when pulling 1a0b326 on parameter-objects into cc127cb on ajs-fix-behavior-tests.

[ghost]

Why getParameterObject is a function, not a method?

[abhinav]

No reason. Changed.

[ghost]

nit: The

[ghost]

I've tried private implementations and it looks very confusing:
foo/foo.go:

package foo

type A struct {}

func (A) private() {
	println("foo")
}

main.go

package main

import (
	"fmt"
	"tmp/foo"
	"reflect"
)

type B struct{foo.A}
type private interface {
	private()
}

func main() {
	b := reflect.ValueOf(B{})
	v := (*private)(nil)
	fmt.Println(reflect.TypeOf(v).Elem())
	fmt.Println(b.Type().Implements(reflect.TypeOf(v).Elem()))
}

the output is:

main.private
true

May be I am doing something wrong, but it seems there could be conflicts if a type has parameterObject() method..

[abhinav]

Interfaces with unexported methods may only be implemented by types defined in
that package. A type that implements a private interface may be embedded
inside another type (which may reside outside the package containing the
private interface). Because methods of embedded types are "inherited", the
type that embeds the other type now implements the private interface too.

That's exactly the behavior we want: Only types that embed dig.Param
implement parameterObject. Demonstration:

// foo/foo.go
package foo

type A interface { private() }

func Matches(x interface{}) bool {
	_, ok := x.(A)
	return ok
}

// External types embedding this will match.
type EmbedMe struct{}

func (EmbedMe) private() {}

// main.go
package main

import (
	"fmt"
	"tmp/foo"
)

type bad struct{}

func (bad) private() {}

type good struct{ foo.EmbedMe }

func main() {
	fmt.Println("bad:", foo.Matches(bad{}))
	fmt.Println("good:", foo.Matches(good{}))
	// Output:
	// bad: false
	// good: true
}

In your example, the other package doesn't define the interface, only the
method. And you embed it in a type inside the package where you define the
interface, so it somehow matches.

This will not work for types that simply implement parameterObject().

[ghost]

I got the trick you are doing, what I am arguing is that Implements(which you are using here) doesn't follow the same behavior as type assertion. If you replace Matches function with it:

func Matches(x interface{}) bool {
	return reflect.TypeOf(x).Implements(reflect.TypeOf((*A)(nil)).Elem())
}

Output is going to be:

bad: true
good: true

[abhinav]

Oh, wow. That's a bug in reflect. Good catch!

[abhinav]

@alsamylkin Created golang/go#20541. Thanks!

[ghost]

Do we need to check if the field is settable? (In case dig will support non-pointer types)

[abhinav]

The field will always be settable because the struct that contains it is addressable (because we created it with reflect.New).

[anuptalwalkar]

parameter term is super generic. Can this error be more explicit? can't provide parameterized object

[abhinav]

I've been using the term "parameter object" for types that embed dig.Param in all the documentation and errors so far. That's the standard name for objects which represent all the parameter of a function, created solely to avoid having too many arguments on the function. See http://wiki.c2.com/?ParameterObject, https://refactoring.com/catalog/introduceParameterObject.html.

We can call this something else, maybe give it a dig-specific name, but "parameterized object" has a whole different meaning.

[anuptalwalkar]

nit: getting parameterObject can be part of c.get(t). Then you don't need to declare variables and assign. implementation wise we just want an object back from container.

[abhinav]

Good call. Updating the other PR with this.

[anuptalwalkar]

nit: refactor? pkgPath and Anonymous is been checked in multiple places.

[abhinav]

Unfortunately that's unavoidable. These are two different entry points. This check is necessary to make sure we don't muck with private fields.

[coveralls]

Coverage increased (+0.2%) to 91.845% when pulling 946fc3d on parameter-objects into c2597a2 on ajs-fix-behavior-tests.

[coveralls]

Coverage increased (+0.2%) to 91.845% when pulling 5720cb9 on parameter-objects into da048de on dev.

[coveralls]

Coverage increased (+0.2%) to 91.845% when pulling 5720cb9 on parameter-objects into da048de on dev.