Support simultanous name and group tags

As per Dig issue:
#380

In order to support Fx feature requests

uber-go/fx#998
uber-go/fx#1036

We need to be able to drop the restriction, both in terms of options
dig.Name and dig.Group and dig.Out struct annotations on `name` and
`group` being mutually exclusive.

In a future PR, this can then be exploited to populate value group maps
where the 'name' tag becomes the key of a map[string][T]

Author: jquirke

decorate.go

@@ -288,7 +288,7 @@ func findResultKeys(r resultList) ([]key, error) {
 			keys = append(keys, key{t: innerResult.Type.Elem(), group: innerResult.Group})
 		case resultObject:
 			for _, f := range innerResult.Fields {
-				q = append(q, f.Result)
+				q = append(q, f.Results...)
 			}
 		case resultList:
 			q = append(q, innerResult.Results...)

dig_test.go

@@ -749,6 +749,53 @@ func TestEndToEndSuccess(t *testing.T) {
 		assert.ElementsMatch(t, actualStrs, expectedStrs, "list of strings provided must match")
 	})
 
+	t.Run("multiple As with Group and Name", func(t *testing.T) {
+		c := digtest.New(t)
+		expectedNames := []string{"inst1", "inst2"}
+		expectedStrs := []string{"foo", "bar"}
+		for i, s := range expectedStrs {
+			s := s
+			c.RequireProvide(func() *bytes.Buffer {
+				return bytes.NewBufferString(s)
+			}, dig.Group("buffs"), dig.Name(expectedNames[i]),
+				dig.As(new(io.Reader), new(io.Writer)))
+		}
+
+		type in struct {
+			dig.In
+
+			Reader1 io.Reader   `name:"inst1"`
+			Reader2 io.Reader   `name:"inst2"`
+			Readers []io.Reader `group:"buffs"`
+			Writers []io.Writer `group:"buffs"`
+		}
+
+		var actualStrs []string
+		var actualStrsName []string
+
+		c.RequireInvoke(func(got in) {
+			require.Len(t, got.Readers, 2)
+			buf := make([]byte, 3)
+			for i, r := range got.Readers {
+				_, err := r.Read(buf)
+				require.NoError(t, err)
+				actualStrs = append(actualStrs, string(buf))
+				// put the text back
+				got.Writers[i].Write(buf)
+			}
+			_, err := got.Reader1.Read(buf)
+			require.NoError(t, err)
+			actualStrsName = append(actualStrsName, string(buf))
+			_, err = got.Reader2.Read(buf)
+			require.NoError(t, err)
+			actualStrsName = append(actualStrsName, string(buf))
+			require.Len(t, got.Writers, 2)
+		})
+
+		assert.ElementsMatch(t, actualStrs, expectedStrs, "list of strings provided must match")
+		assert.ElementsMatch(t, actualStrsName, expectedStrs, "names: list of strings provided must match")
+	})
+
 	t.Run("As same interface", func(t *testing.T) {
 		c := digtest.New(t)
 		c.RequireProvide(func() io.Reader {
@@ -1098,6 +1145,48 @@ func TestGroups(t *testing.T) {
 		})
 	})
 
+	t.Run("values are provided; coexist with name", func(t *testing.T) {
+		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
+
+		type out struct {
+			dig.Out
+
+			Value int `group:"val"`
+		}
+
+		type out2 struct {
+			dig.Out
+
+			Value int `name:"inst1" group:"val"`
+		}
+
+		provide := func(i int) {
+			c.RequireProvide(func() out {
+				return out{Value: i}
+			})
+		}
+
+		provide(1)
+		provide(2)
+		provide(3)
+
+		c.RequireProvide(func() out2 {
+			return out2{Value: 4}
+		})
+
+		type in struct {
+			dig.In
+
+			SingleValue int   `name:"inst1"`
+			Values      []int `group:"val"`
+		}
+
+		c.RequireInvoke(func(i in) {
+			assert.Equal(t, []int{1, 2, 3, 4}, i.Values)
+			assert.Equal(t, 4, i.SingleValue)
+		})
+	})
+
 	t.Run("groups are provided via option", func(t *testing.T) {
 		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
 
@@ -1122,6 +1211,36 @@ func TestGroups(t *testing.T) {
 		})
 	})
 
+	t.Run("groups are provided via option; coexist with name", func(t *testing.T) {
+		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
+
+		provide := func(i int) {
+			c.RequireProvide(func() int {
+				return i
+			}, dig.Group("val"))
+		}
+
+		provide(1)
+		provide(2)
+		provide(3)
+
+		c.RequireProvide(func() int {
+			return 4
+		}, dig.Group("val"), dig.Name("inst1"))
+
+		type in struct {
+			dig.In
+
+			SingleValue int   `name:"inst1"`
+			Values      []int `group:"val"`
+		}
+
+		c.RequireInvoke(func(i in) {
+			assert.Equal(t, []int{1, 2, 3, 4}, i.Values)
+			assert.Equal(t, 4, i.SingleValue)
+		})
+	})
+
 	t.Run("different types may be grouped", func(t *testing.T) {
 		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
 
@@ -1429,6 +1548,44 @@ func TestGroups(t *testing.T) {
 		})
 	})
 
+	t.Run("flatten collects slices but also handles name", func(t *testing.T) {
+		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
+
+		type out1 struct {
+			dig.Out
+
+			Value []int `name:"foo1" group:"val,flatten"`
+		}
+
+		type out2 struct {
+			dig.Out
+
+			Value []int `name:"foo2" group:"val,flatten"`
+		}
+
+		c.RequireProvide(func() out1 {
+			return out1{Value: []int{1, 2}}
+		})
+
+		c.RequireProvide(func() out2 {
+			return out2{Value: []int{3, 4}}
+		})
+
+		type in struct {
+			dig.In
+
+			NotFlattenedSlice1 []int `name:"foo1"`
+			NotFlattenedSlice2 []int `name:"foo2"`
+			Values             []int `group:"val"`
+		}
+
+		c.RequireInvoke(func(i in) {
+			assert.Equal(t, []int{2, 3, 4, 1}, i.Values)
+			assert.Equal(t, []int{1, 2}, i.NotFlattenedSlice1)
+			assert.Equal(t, []int{3, 4}, i.NotFlattenedSlice2)
+		})
+	})
+
 	t.Run("flatten via option", func(t *testing.T) {
 		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
 		c.RequireProvide(func() []int {
@@ -1446,6 +1603,31 @@ func TestGroups(t *testing.T) {
 		})
 	})
 
+	t.Run("flatten via option also handles name", func(t *testing.T) {
+		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
+		c.RequireProvide(func() []int {
+			return []int{1, 2}
+		}, dig.Group("val,flatten"), dig.Name("foo1"))
+
+		c.RequireProvide(func() []int {
+			return []int{3}
+		}, dig.Group("val,flatten"), dig.Name("foo2"))
+
+		type in struct {
+			dig.In
+
+			NotFlattenedSlice1 []int `name:"foo1"`
+			NotFlattenedSlice2 []int `name:"foo2"`
+			Values             []int `group:"val"`
+		}
+
+		c.RequireInvoke(func(i in) {
+			assert.Equal(t, []int{2, 3, 1}, i.Values)
+			assert.Equal(t, []int{1, 2}, i.NotFlattenedSlice1)
+			assert.Equal(t, []int{3}, i.NotFlattenedSlice2)
+		})
+	})
+
 	t.Run("flatten via option error if not a slice", func(t *testing.T) {
 		c := digtest.New(t, dig.SetRand(rand.New(rand.NewSource(0))))
 		err := c.Provide(func() int { return 1 }, dig.Group("val,flatten"))
@@ -1998,21 +2180,6 @@ func TestAsExpectingOriginalType(t *testing.T) {
 	})
 }
 
-func TestProvideIncompatibleOptions(t *testing.T) {
-	t.Parallel()
-
-	t.Run("group and name", func(t *testing.T) {
-		c := digtest.New(t)
-		err := c.Provide(func() io.Reader {
-			t.Fatal("this function must not be called")
-			return nil
-		}, dig.Group("foo"), dig.Name("bar"))
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), "cannot use named values with value groups: "+
-			`name:"bar" provided with group:"foo"`)
-	})
-}
-
 type testStruct struct{}
 
 func (testStruct) TestMethod(x int) float64 { return float64(x) }
@@ -2559,6 +2726,60 @@ func testProvideFailures(t *testing.T, dryRun bool) {
 		)
 	})
 
+	t.Run("provide multiple instances with the same name and same group", func(t *testing.T) {
+		c := digtest.New(t, dig.DryRun(dryRun))
+		type A struct{}
+		type ret1 struct {
+			dig.Out
+			*A `name:"foo" group:"foos"`
+		}
+		type ret2 struct {
+			dig.Out
+			*A `name:"foo" group:"foos"`
+		}
+		c.RequireProvide(func() ret1 {
+			return ret1{A: &A{}}
+		})
+
+		err := c.Provide(func() ret2 {
+			return ret2{A: &A{}}
+		})
+		require.Error(t, err, "expected error on the second provide")
+		dig.AssertErrorMatches(t, err,
+			`cannot provide function "go.uber.org/dig_test".testProvideFailures\S+`,
+			`dig_test.go:\d+`, // file:line
+			`cannot provide \*dig_test.A\[name="foo"\] from \[0\].A:`,
+			`already provided by "go.uber.org/dig_test".testProvideFailures\S+`,
+		)
+	})
+
+	t.Run("provide multiple instances with the same name but different group", func(t *testing.T) {
+		c := digtest.New(t, dig.DryRun(dryRun))
+		type A struct{}
+		type ret1 struct {
+			dig.Out
+			*A `name:"foo" group:"foos"`
+		}
+		type ret2 struct {
+			dig.Out
+			*A `name:"foo" group:"foosss"`
+		}
+		c.RequireProvide(func() ret1 {
+			return ret1{A: &A{}}
+		})
+
+		err := c.Provide(func() ret2 {
+			return ret2{A: &A{}}
+		})
+		require.Error(t, err, "expected error on the second provide")
+		dig.AssertErrorMatches(t, err,
+			`cannot provide function "go.uber.org/dig_test".testProvideFailures\S+`,
+			`dig_test.go:\d+`, // file:line
+			`cannot provide \*dig_test.A\[name="foo"\] from \[0\].A:`,
+			`already provided by "go.uber.org/dig_test".testProvideFailures\S+`,
+		)
+	})
+
 	t.Run("out with unexported field should error", func(t *testing.T) {
 		c := digtest.New(t, dig.DryRun(dryRun))
 

provide.go

@@ -46,12 +46,6 @@ type provideOptions struct {
 }
 
 func (o *provideOptions) Validate() error {
-	if len(o.Group) > 0 {
-		if len(o.Name) > 0 {
-			return newErrInvalidInput(
-				fmt.Sprintf("cannot use named values with value groups: name:%q provided with group:%q", o.Name, o.Group), nil)
-		}
-	}
 
 	// Names must be representable inside a backquoted string. The only
 	// limitation for raw string literals as per