goose: add interface binding

An interface binding instructs goose that a concrete type should be used
to satisfy a dependency on an interface type. goose could determine this
implicitly, but having an explicit directive makes the provider author's
intent clear and allows different concrete types to satisfy different
smaller interfaces.

Reviewed-by: Tuo Shan <shantuo@google.com>

internal/goose/testdata/ImportedInterfaceBinding/bar/bar.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+
+	_ "foo"
+)
+
+func main() {
+	fmt.Println(injectFooer().Foo())
+}
+
+type Bar string
+
+func (b *Bar) Foo() string {
+	return string(*b)
+}
+
+//goose:provide
+func provideBar() *Bar {
+	b := new(Bar)
+	*b = "Hello, World!"
+	return b
+}
+
+//goose:bind provideBar "foo".Fooer *Bar

internal/goose/testdata/ImportedInterfaceBinding/bar/goose.go

@@ -0,0 +1,9 @@
+//+build gooseinject
+
+package main
+
+import "foo"
+
+//goose:use provideBar
+
+func injectFooer() foo.Fooer

internal/goose/testdata/ImportedInterfaceBinding/foo/foo.go

@@ -0,0 +1,5 @@
+package foo
+
+type Fooer interface {
+	Foo() string
+}

internal/goose/testdata/ImportedInterfaceBinding/out.txt

@@ -0,0 +1 @@
+Hello, World!

internal/goose/testdata/ImportedInterfaceBinding/pkg

@@ -0,0 +1 @@
+bar

internal/goose/testdata/InterfaceBinding/foo/foo.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(injectFooer().Foo())
+}
+
+type Fooer interface {
+	Foo() string
+}
+
+type Bar string
+
+func (b *Bar) Foo() string {
+	return string(*b)
+}
+
+//goose:provide
+func provideBar() *Bar {
+	b := new(Bar)
+	*b = "Hello, World!"
+	return b
+}
+
+//goose:bind provideBar Fooer *Bar

internal/goose/testdata/InterfaceBinding/foo/foo_goose.go

@@ -0,0 +1,7 @@
+//+build gooseinject
+
+package main
+
+//goose:use provideBar
+
+func injectFooer() Fooer

internal/goose/testdata/InterfaceBinding/out.txt

@@ -0,0 +1 @@
+Hello, World!

internal/goose/testdata/InterfaceBinding/pkg

@@ -0,0 +1 @@
+foo

internal/goose/testdata/InterfaceBindingReuse/foo/foo.go

@@ -0,0 +1,50 @@
+// This test verifies that the concrete type is provided only once, even if an
+// interface additionally depends on it.
+
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+func main() {
+	injectFooBar()
+	fmt.Println(provideBarCalls)
+}
+
+type Fooer interface {
+	Foo() string
+}
+
+type Bar string
+
+type FooBar struct {
+	Fooer Fooer
+	Bar   *Bar
+}
+
+func (b *Bar) Foo() string {
+	return string(*b)
+}
+
+//goose:provide
+//goose:bind provideBar Fooer *Bar
+func provideBar() *Bar {
+	mu.Lock()
+	provideBarCalls++
+	mu.Unlock()
+	b := new(Bar)
+	*b = "Hello, World!"
+	return b
+}
+
+var (
+	mu              sync.Mutex
+	provideBarCalls int
+)
+
+//goose:provide
+func provideFooBar(fooer Fooer, bar *Bar) FooBar {
+	return FooBar{fooer, bar}
+}

internal/goose/testdata/InterfaceBindingReuse/foo/foo_goose.go

@@ -0,0 +1,8 @@
+//+build gooseinject
+
+package main
+
+//goose:use provideBar
+//goose:use provideFooBar
+
+func injectFooBar() FooBar

internal/goose/testdata/InterfaceBindingReuse/out.txt

@@ -0,0 +1 @@
+1

internal/goose/testdata/InterfaceBindingReuse/pkg

@@ -0,0 +1 @@
+foo

internal/goose/testdata/NoImplicitInterface/foo/foo.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(injectFooer().Foo())
+}
+
+type Fooer interface {
+	Foo() string
+}
+
+type Bar string
+
+func (b Bar) Foo() string {
+	return string(b)
+}
+
+//goose:provide
+func provideBar() Bar {
+	return "Hello, World!"
+}

internal/goose/testdata/NoImplicitInterface/foo/foo_goose.go

@@ -0,0 +1,7 @@
+//+build gooseinject
+
+package main
+
+//goose:use provideBar
+
+func injectFooer() Fooer

internal/goose/testdata/NoImplicitInterface/out.txt

@@ -0,0 +1 @@
+ERROR

internal/goose/testdata/NoImplicitInterface/pkg

@@ -0,0 +1 @@
+foo